Cleanup in //runtime/bin

runtime/bin/process_android.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_ANDROID)
 
 #include "bin/process.h"
 
 #include <errno.h>  // NOLINT
 #include <fcntl.h>  // NOLINT
 #include <poll.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <stdlib.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/wait.h>  // NOLINT
 #include <unistd.h>  // NOLINT
 
 #include "bin/dartutils.h"
 #include "bin/fdutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
-
 extern char **environ;
 
-
 namespace dart {
 namespace bin {
 
 // ProcessInfo is used to map a process id to the file descriptor for
 // the pipe used to communicate the exit code of the process to Dart.
 // ProcessInfo objects are kept in the static singly-linked
 // ProcessInfoList.
 class ProcessInfo {
  public:
   ProcessInfo(pid_t pid, intptr_t fd) : pid_(pid), fd_(fd) { }
   ~ProcessInfo() {
     int closed = TEMP_FAILURE_RETRY(close(fd_));
     if (closed != 0) {
       FATAL("Failed to close process exit code pipe");
     }
   }
   pid_t pid() { return pid_; }
   intptr_t fd() { return fd_; }
   ProcessInfo* next() { return next_; }
   void set_next(ProcessInfo* info) { next_ = info; }
 
  private:
   pid_t pid_;
   intptr_t fd_;
   ProcessInfo* next_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessInfo);
 };
 
 
 // Singly-linked list of ProcessInfo objects for all active processes
 // started from Dart.
 class ProcessInfoList {
  public:
   static void AddProcess(pid_t pid, intptr_t fd) {
     MutexLocker locker(mutex_);
     ProcessInfo* info = new ProcessInfo(pid, fd);
@@ skipping 34 matching lines @@
     }
   }
 
  private:
   // Linked list of ProcessInfo objects for all active processes
   // started from Dart code.
   static ProcessInfo* active_processes_;
   // Mutex protecting all accesses to the linked list of active
   // processes.
   static Mutex* mutex_;
+
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessInfoList);
 };
 
 
 ProcessInfo* ProcessInfoList::active_processes_ = NULL;
 Mutex* ProcessInfoList::mutex_ = new Mutex();
 
 
 // The exit code handler sets up a separate thread which waits for child
 // processes to terminate. That separate thread can then get the exit code from
 // processes that have exited and communicate it to Dart through the
@@ skipping 47 matching lines @@
 
  private:
   // Entry point for the separate exit code handler thread started by
   // the ExitCodeHandler.
   static void ExitCodeHandlerEntry(uword param) {
     pid_t pid = 0;
     int status = 0;
     while (true) {
       {
         MonitorLocker locker(monitor_);
-        while (running_ && process_count_ == 0) {
+        while (running_ && (process_count_ == 0)) {
           monitor_->Wait(Monitor::kNoTimeout);
         }
         if (!running_) {
           terminate_done_ = true;
           monitor_->Notify();
           return;
         }
       }
 
       if ((pid = TEMP_FAILURE_RETRY(wait(&status))) > 0) {
         int exit_code = 0;
         int negative = 0;
         if (WIFEXITED(status)) {
           exit_code = WEXITSTATUS(status);
         }
         if (WIFSIGNALED(status)) {
           exit_code = WTERMSIG(status);
           negative = 1;
         }
         intptr_t exit_code_fd = ProcessInfoList::LookupProcessExitFd(pid);
         if (exit_code_fd != 0) {
           int message[2] = { exit_code, negative };
           ssize_t result =
               FDUtils::WriteToBlocking(exit_code_fd, &message, sizeof(message));
           // If the process has been closed, the read end of the exit
           // pipe has been closed. It is therefore not a problem that
           // write fails with a broken pipe error. Other errors should
           // not happen.
-          if (result != -1 && result != sizeof(message)) {
+          if ((result != -1) && (result != sizeof(message))) {
             FATAL("Failed to write entire process exit message");
-          } else if (result == -1 && errno != EPIPE) {
+          } else if ((result == -1) && (errno != EPIPE)) {
             FATAL1("Failed to write exit code: %d", errno);
           }
           ProcessInfoList::RemoveProcess(pid);
           {
             MonitorLocker locker(monitor_);
             process_count_--;
           }
         }
       }
     }
   }
 
   static bool terminate_done_;
   static int process_count_;
   static bool running_;
   static Monitor* monitor_;
+
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ExitCodeHandler);
 };
 
 
 bool ExitCodeHandler::running_ = false;
 int ExitCodeHandler::process_count_ = 0;
 bool ExitCodeHandler::terminate_done_ = false;
 Monitor* ExitCodeHandler::monitor_ = new Monitor();
 
 
 class ProcessStarter {
@@ skipping 22 matching lines @@
         os_error_message_(os_error_message) {
     read_in_[0] = -1;
     read_in_[1] = -1;
     read_err_[0] = -1;
     read_err_[1] = -1;
     write_out_[0] = -1;
     write_out_[1] = -1;
     exec_control_[0] = -1;
     exec_control_[1] = -1;
 
-    program_arguments_ = new char*[arguments_length + 2];
+    program_arguments_ = reinterpret_cast<char**>(Dart_ScopeAllocate(
+        (arguments_length + 2) * sizeof(*program_arguments_)));
     program_arguments_[0] = const_cast<char*>(path_);
     for (int i = 0; i < arguments_length; i++) {
       program_arguments_[i + 1] = arguments[i];
     }
     program_arguments_[arguments_length + 1] = NULL;
 
     program_environment_ = NULL;
     if (environment != NULL) {
-      program_environment_ = new char*[environment_length + 1];
+      program_environment_ = reinterpret_cast<char**>(Dart_ScopeAllocate(
+          (environment_length + 1) * sizeof(*program_environment_)));
       for (int i = 0; i < environment_length; i++) {
         program_environment_[i] = environment[i];
       }
       program_environment_[environment_length] = NULL;
     }
   }
 
 
-  ~ProcessStarter() {
-    delete[] program_arguments_;
-    delete[] program_environment_;
-  }
-
-
   int Start() {
     // Create pipes required.
     int err = CreatePipes();
-    if (err != 0) return err;
+    if (err != 0) {
+      return err;
+    }
 
     // Fork to create the new process.
     pid_t pid = TEMP_FAILURE_RETRY(fork());
     if (pid < 0) {
       // Failed to fork.
       return CleanupAndReturnError();
     } else if (pid == 0) {
       // This runs in the new process.
       NewProcess();
     }
 
     // This runs in the original process.
 
     // Be sure to listen for exit-codes, now we have a child-process.
     ExitCodeHandler::ProcessStarted();
 
     // Register the child process if not detached.
     if (mode_ == kNormal) {
       err = RegisterProcess(pid);
-      if (err != 0) return err;
+      if (err != 0) {
+        return err;
+      }
     }
 
     // Notify child process to start. This is done to delay the call to exec
     // until the process is registered above, and we are ready to receive the
     // exit code.
     char msg = '1';
     int bytes_written =
         FDUtils::WriteToBlocking(read_in_[1], &msg, sizeof(msg));
     if (bytes_written != sizeof(msg)) {
       return CleanupAndReturnError();
@@ skipping 158 matching lines @@
         pid = TEMP_FAILURE_RETRY(fork());
         if (pid < 0) {
           ReportChildError();
         } else if (pid == 0) {
           if (mode_ == kDetached) {
             SetupDetached();
           } else {
             SetupDetachedWithStdio();
           }
 
-          if (working_directory_ != NULL &&
-              TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1) {
+          if ((working_directory_ != NULL) &&
+              (TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1)) {
             ReportChildError();
           }
 
           // Report the final PID and do the exec.
           ReportPid(getpid());  // getpid cannot fail.
           VOID_TEMP_FAILURE_RETRY(
               execvp(path_, const_cast<char* const*>(program_arguments_)));
           ReportChildError();
         } else {
           // Exit the intermeiate process.
@@ skipping 21 matching lines @@
     return 0;
   }
 
 
   int ReadExecResult() {
     int child_errno;
     int bytes_read = -1;
     // Read exec result from child. If no data is returned the exec was
     // successful and the exec call closed the pipe. Otherwise the errno
     // is written to the pipe.
-    bytes_read =
-        FDUtils::ReadFromBlocking(
-            exec_control_[0], &child_errno, sizeof(child_errno));
+    bytes_read = FDUtils::ReadFromBlocking(
+        exec_control_[0], &child_errno, sizeof(child_errno));
     if (bytes_read == sizeof(child_errno)) {
       ReadChildError();
       return child_errno;
     } else if (bytes_read == -1) {
       return errno;
     }
     return 0;
   }
 
 
   int ReadDetachedExecResult(pid_t *pid) {
     int child_errno;
     int bytes_read = -1;
     // Read exec result from child. If only pid data is returned the exec was
     // successful and the exec call closed the pipe. Otherwise the errno
     // is written to the pipe as well.
     int result[2];
     bytes_read =
-        FDUtils::ReadFromBlocking(
-            exec_control_[0], result, sizeof(result));
+        FDUtils::ReadFromBlocking(exec_control_[0], result, sizeof(result));
     if (bytes_read == sizeof(int)) {
       *pid = result[0];
     } else if (bytes_read == 2 * sizeof(int)) {
       *pid = result[0];
       child_errno = result[1];
       ReadChildError();
       return child_errno;
     } else if (bytes_read == -1) {
       return errno;
     }
     return 0;
   }
 
 
   void SetupDetached() {
     ASSERT(mode_ == kDetached);
 
     // Close all open file descriptors except for exec_control_[1].
     int max_fds = sysconf(_SC_OPEN_MAX);
-    if (max_fds == -1) max_fds = _POSIX_OPEN_MAX;
+    if (max_fds == -1) {
+      max_fds = _POSIX_OPEN_MAX;
+    }
     for (int fd = 0; fd < max_fds; fd++) {
       if (fd != exec_control_[1]) {
         VOID_TEMP_FAILURE_RETRY(close(fd));
       }
     }
 
     // Re-open stdin, stdout and stderr and connect them to /dev/null.
     // The loop above should already have closed all of them, so
     // creating new file descriptors should start at STDIN_FILENO.
     int fd = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
     if (fd != STDIN_FILENO) {
       ReportChildError();
     }
     if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDOUT_FILENO)) !=
         STDOUT_FILENO) {
       ReportChildError();
     }
     if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDERR_FILENO)) !=
         STDERR_FILENO) {
       ReportChildError();
     }
   }
 
   void SetupDetachedWithStdio() {
     // Close all open file descriptors except for
     // exec_control_[1], write_out_[0], read_in_[1] and
     // read_err_[1].
     int max_fds = sysconf(_SC_OPEN_MAX);
-    if (max_fds == -1) max_fds = _POSIX_OPEN_MAX;
+    if (max_fds == -1) {
+      max_fds = _POSIX_OPEN_MAX;
+    }
     for (int fd = 0; fd < max_fds; fd++) {
-      if (fd != exec_control_[1] &&
-          fd != write_out_[0] &&
-          fd != read_in_[1] &&
-          fd != read_err_[1]) {
+      if ((fd != exec_control_[1]) &&
+          (fd != write_out_[0]) &&
+          (fd != read_in_[1]) &&
+          (fd != read_err_[1])) {
         VOID_TEMP_FAILURE_RETRY(close(fd));
       }
     }
 
     if (TEMP_FAILURE_RETRY(dup2(write_out_[0], STDIN_FILENO)) == -1) {
       ReportChildError();
     }
     VOID_TEMP_FAILURE_RETRY(close(write_out_[0]));
 
     if (TEMP_FAILURE_RETRY(dup2(read_in_[1], STDOUT_FILENO)) == -1) {
@@ skipping 100 matching lines @@
 
   const char* path_;
   const char* working_directory_;
   ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_event_;
   char** os_error_message_;
+
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessStarter);
 };
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
                    ProcessStartMode mode,
@@ skipping 15 matching lines @@
                          err,
                          id,
                          exit_event,
                          os_error_message);
   return starter.Start();
 }
 
 
 class BufferList: public BufferListBase {
  public:
+  BufferList() {}
+
   bool Read(int fd, intptr_t available) {
     // Read all available bytes.
     while (available > 0) {
-      if (free_size_ == 0) Allocate();
+      if (free_size_ == 0) {
+        Allocate();
+      }
       ASSERT(free_size_ > 0);
       ASSERT(free_size_ <= kBufferSize);
       intptr_t block_size = dart::Utils::Minimum(free_size_, available);
       intptr_t bytes = TEMP_FAILURE_RETRY(read(
           fd,
           reinterpret_cast<void*>(FreeSpaceAddress()),
           block_size));
-      if (bytes < 0) return false;
+      if (bytes < 0) {
+        return false;
+      }
       data_size_ += bytes;
       free_size_ -= bytes;
       available -= bytes;
     }
     return true;
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BufferList);
 };
 
 
 static bool CloseProcessBuffers(struct pollfd fds[3]) {
   int e = errno;
   VOID_TEMP_FAILURE_RETRY(close(fds[0].fd));
   VOID_TEMP_FAILURE_RETRY(close(fds[1].fd));
   VOID_TEMP_FAILURE_RETRY(close(fds[2].fd));
   errno = e;
   return false;
@@ skipping 31 matching lines @@
   int alive = 3;
   while (alive > 0) {
     // Blocking call waiting for events from the child process.
     if (TEMP_FAILURE_RETRY(poll(fds, alive, -1)) <= 0) {
       return CloseProcessBuffers(fds);
     }
 
     // Process incoming data.
     int current_alive = alive;
     for (int i = 0; i < current_alive; i++) {
-      if (fds[i].revents & POLLIN) {
+      if ((fds[i].revents & POLLIN) != 0) {
         intptr_t avail = FDUtils::AvailableBytes(fds[i].fd);
         if (fds[i].fd == out) {
           if (!out_data.Read(out, avail)) {
             return CloseProcessBuffers(fds);
           }
         } else if (fds[i].fd == err) {
           if (!err_data.Read(err, avail)) {
             return CloseProcessBuffers(fds);
           }
         } else if (fds[i].fd == exit_event) {
           if (avail == 8) {
             intptr_t b = TEMP_FAILURE_RETRY(read(exit_event,
                                                  exit_code_data.bytes, 8));
             if (b != 8) {
               return CloseProcessBuffers(fds);
             }
           }
         } else {
           UNREACHABLE();
         }
       }
-      if (fds[i].revents & POLLHUP) {
+      if ((fds[i].revents & POLLHUP) != 0) {
         VOID_TEMP_FAILURE_RETRY(close(fds[i].fd));
         alive--;
         if (i < alive) {
           fds[i] = fds[alive];
         }
       }
     }
   }
 
   // All handles closed and all data read.
   result->set_stdout_data(out_data.GetData());
   result->set_stderr_data(err_data.GetData());
 
   // Calculate the exit code.
   intptr_t exit_code = exit_code_data.ints[0];
   intptr_t negative = exit_code_data.ints[1];
-  if (negative) exit_code = -exit_code;
+  if (negative != 0) {
+    exit_code = -exit_code;
+  }
   result->set_exit_code(exit_code);
 
   return true;
 }
 
 
 bool Process::Kill(intptr_t id, int signal) {
   return (TEMP_FAILURE_RETRY(kill(id, signal)) != -1);
 }
 
@@ skipping 41 matching lines @@
 
 
 intptr_t Process::SetSignalHandler(intptr_t signal) {
   bool found = false;
   for (int i = 0; i < kSignalsCount; i++) {
     if (kSignals[i] == signal) {
       found = true;
       break;
     }
   }
-  if (!found) return -1;
+  if (!found) {
+    return -1;
+  }
   int fds[2];
   if (NO_RETRY_EXPECTED(pipe2(fds, O_CLOEXEC)) != 0) {
     return -1;
   }
   if (!FDUtils::SetNonBlocking(fds[0])) {
     VOID_TEMP_FAILURE_RETRY(close(fds[0]));
     VOID_TEMP_FAILURE_RETRY(close(fds[1]));
     return -1;
   }
   ThreadSignalBlocker blocker(kSignalsCount, kSignals);
@@ skipping 29 matching lines @@
 
 void Process::ClearSignalHandler(intptr_t signal) {
   ThreadSignalBlocker blocker(kSignalsCount, kSignals);
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;
   bool unlisten = true;
   while (handler != NULL) {
     bool remove = false;
     if (handler->signal() == signal) {
       if (handler->port() == Dart_GetMainPortId()) {
-        if (signal_handlers == handler) signal_handlers = handler->next();
+        if (signal_handlers == handler) {
+          signal_handlers = handler->next();
+        }
         handler->Unlink();
         remove = true;
       } else {
         unlisten = false;
       }
     }
     SignalInfo* next = handler->next();
-    if (remove) delete handler;
+    if (remove) {
+      delete handler;
+    }
     handler = next;
   }
   if (unlisten) {
     struct sigaction act;
     bzero(&act, sizeof(act));
     act.sa_handler = SIG_DFL;
     VOID_NO_RETRY_EXPECTED(sigaction(signal, &act, NULL));
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_ANDROID)