VM: Re-format to use at most one newline between functions

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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(HOST_OS_ANDROID)
 
 #include "bin/process.h"
@@ skipping 46 matching lines @@
   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);
     info->set_next(active_processes_);
     active_processes_ = info;
   }
 
-
   static intptr_t LookupProcessExitFd(pid_t pid) {
     MutexLocker locker(mutex_);
     ProcessInfo* current = active_processes_;
     while (current != NULL) {
       if (current->pid() == pid) {
         return current->fd();
       }
       current = current->next();
     }
     return 0;
   }
 
-
   static void RemoveProcess(pid_t pid) {
     MutexLocker locker(mutex_);
     ProcessInfo* prev = NULL;
     ProcessInfo* current = active_processes_;
     while (current != NULL) {
       if (current->pid() == pid) {
         if (prev == NULL) {
           active_processes_ = current->next();
         } else {
           prev->set_next(current->next());
@@ skipping 11 matching lines @@
   // 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
 // event loop.
 class ExitCodeHandler {
  public:
   // Notify the ExitCodeHandler that another process exists.
   static void ProcessStarted() {
     // Multiple isolates could be starting processes at the same
     // time. Make sure that only one ExitCodeHandler thread exists.
@@ skipping 96 matching lines @@
 
   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 {
  public:
   ProcessStarter(const char* path,
                  char* arguments[],
                  intptr_t arguments_length,
                  const char* working_directory,
                  char* environment[],
                  intptr_t environment_length,
                  ProcessStartMode mode,
                  intptr_t* in,
@@ skipping 32 matching lines @@
     if (environment != NULL) {
       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;
     }
   }
 
-
   int Start() {
     // Create pipes required.
     int err = CreatePipes();
     if (err != 0) {
       return err;
     }
 
     // Fork to create the new process.
     pid_t pid = TEMP_FAILURE_RETRY(fork());
     if (pid < 0) {
@@ skipping 104 matching lines @@
 
       result = TEMP_FAILURE_RETRY(pipe2(write_out_, O_CLOEXEC));
       if (result < 0) {
         return CleanupAndReturnError();
       }
     }
 
     return 0;
   }
 
-
   void NewProcess() {
     // Wait for parent process before setting up the child process.
     char msg;
     int bytes_read = FDUtils::ReadFromBlocking(read_in_[0], &msg, sizeof(msg));
     if (bytes_read != sizeof(msg)) {
       perror("Failed receiving notification message");
       exit(1);
     }
     if (mode_ == kNormal) {
       ExecProcess();
     } else {
       ExecDetachedProcess();
     }
   }
 
-
   void ExecProcess() {
     if (TEMP_FAILURE_RETRY(dup2(write_out_[0], STDIN_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (TEMP_FAILURE_RETRY(dup2(read_in_[1], STDOUT_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (TEMP_FAILURE_RETRY(dup2(read_err_[1], STDERR_FILENO)) == -1) {
       ReportChildError();
     }
 
     if (working_directory_ != NULL &&
         TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1) {
       ReportChildError();
     }
 
     if (program_environment_ != NULL) {
       environ = program_environment_;
     }
 
     VOID_TEMP_FAILURE_RETRY(
         execvp(path_, const_cast<char* const*>(program_arguments_)));
 
     ReportChildError();
   }
 
-
   void ExecDetachedProcess() {
     if (mode_ == kDetached) {
       ASSERT(write_out_[0] == -1);
       ASSERT(write_out_[1] == -1);
       ASSERT(read_err_[0] == -1);
       ASSERT(read_err_[1] == -1);
       // For a detached process the pipe to connect stdout is only used for
       // signaling when to do the first fork.
       VOID_TEMP_FAILURE_RETRY(close(read_in_[0]));
       read_in_[0] = -1;
@@ skipping 37 matching lines @@
           // Exit the intermediate process.
           exit(0);
         }
       }
     } else {
       // Exit the intermediate process.
       exit(0);
     }
   }
 
-
   int RegisterProcess(pid_t pid) {
     int result;
     int event_fds[2];
     result = TEMP_FAILURE_RETRY(pipe2(event_fds, O_CLOEXEC));
     if (result < 0) {
       return CleanupAndReturnError();
     }
 
     ProcessInfoList::AddProcess(pid, event_fds[1]);
     *exit_event_ = event_fds[0];
     FDUtils::SetNonBlocking(event_fds[0]);
     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));
     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));
     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;
     }
     for (int fd = 0; fd < max_fds; fd++) {
       if (fd != exec_control_[1]) {
@@ skipping 42 matching lines @@
       ReportChildError();
     }
     VOID_TEMP_FAILURE_RETRY(close(read_in_[1]));
 
     if (TEMP_FAILURE_RETRY(dup2(read_err_[1], STDERR_FILENO)) == -1) {
       ReportChildError();
     }
     VOID_TEMP_FAILURE_RETRY(close(read_err_[1]));
   }
 
-
   int CleanupAndReturnError() {
     int actual_errno = errno;
     // If CleanupAndReturnError is called without an actual errno make
     // sure to return an error anyway.
     if (actual_errno == 0) {
       actual_errno = EPERM;
     }
     SetChildOsErrorMessage();
     CloseAllPipes();
     return actual_errno;
   }
 
-
   void SetChildOsErrorMessage() {
     const int kBufferSize = 1024;
     char* error_message = DartUtils::ScopedCString(kBufferSize);
     Utils::StrError(errno, error_message, kBufferSize);
     *os_error_message_ = error_message;
   }
 
-
   void ReportChildError() {
     // In the case of failure in the child process write the errno and
     // the OS error message to the exec control pipe and exit.
     int child_errno = errno;
     const int kBufferSize = 1024;
     char os_error_message[kBufferSize];
     Utils::StrError(errno, os_error_message, kBufferSize);
     int bytes_written = FDUtils::WriteToBlocking(exec_control_[1], &child_errno,
                                                  sizeof(child_errno));
     if (bytes_written == sizeof(child_errno)) {
       FDUtils::WriteToBlocking(exec_control_[1], os_error_message,
                                strlen(os_error_message) + 1);
     }
     VOID_TEMP_FAILURE_RETRY(close(exec_control_[1]));
 
     // We avoid running through registered atexit() handlers because that is
     // unnecessary work.
     _exit(1);
   }
 
-
   void ReportPid(int pid) {
     // In the case of starting a detached process the actual pid of that process
     // is communicated using the exec control pipe.
     int bytes_written =
         FDUtils::WriteToBlocking(exec_control_[1], &pid, sizeof(pid));
     ASSERT(bytes_written == sizeof(int));
     USE(bytes_written);
   }
 
-
   void ReadChildError() {
     const int kMaxMessageSize = 256;
     char* message = DartUtils::ScopedCString(kMaxMessageSize);
     if (message != NULL) {
       FDUtils::ReadFromBlocking(exec_control_[0], message, kMaxMessageSize);
       message[kMaxMessageSize - 1] = '\0';
       *os_error_message_ = message;
     } else {
       // Could not get error message. It will be NULL.
       ASSERT(*os_error_message_ == NULL);
     }
   }
 
-
   void ClosePipe(int* fds) {
     for (int i = 0; i < 2; i++) {
       if (fds[i] != -1) {
         VOID_TEMP_FAILURE_RETRY(close(fds[i]));
         fds[i] = -1;
       }
     }
   }
 
-
   void CloseAllPipes() {
     ClosePipe(exec_control_);
     ClosePipe(read_in_);
     ClosePipe(read_err_);
     ClosePipe(write_out_);
   }
 
-
   int read_in_[2];       // Pipe for stdout to child process.
   int read_err_[2];      // Pipe for stderr to child process.
   int write_out_[2];     // Pipe for stdin to child process.
   int exec_control_[2];  // Pipe to get the result from exec.
 
   char** program_arguments_;
   char** program_environment_;
 
   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,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_event,
                    char** os_error_message) {
   ProcessStarter starter(path, arguments, arguments_length, working_directory,
                          environment, environment_length, mode, in, out, err,
                          id, exit_event, os_error_message);
   return starter.Start();
 }
 
-
 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;
 }
 
-
 bool Process::Wait(intptr_t pid,
                    intptr_t in,
                    intptr_t out,
                    intptr_t err,
                    intptr_t exit_event,
                    ProcessResult* result) {
   // Close input to the process right away.
   VOID_TEMP_FAILURE_RETRY(close(in));
 
   // There is no return from this function using Dart_PropagateError
@@ skipping 67 matching lines @@
   intptr_t exit_code = exit_code_data.ints[0];
   intptr_t negative = exit_code_data.ints[1];
   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);
 }
 
-
 void Process::TerminateExitCodeHandler() {
   ExitCodeHandler::TerminateExitCodeThread();
 }
 
-
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(getpid());
 }
 
-
 int64_t Process::CurrentRSS() {
   // The second value in /proc/self/statm is the current RSS in pages.
   File* statm = File::Open("/proc/self/statm", File::kRead);
   if (statm == NULL) {
     return -1;
   }
   RefCntReleaseScope<File> releaser(statm);
   const intptr_t statm_length = 1 * KB;
   void* buffer = reinterpret_cast<void*>(Dart_ScopeAllocate(statm_length));
   const intptr_t statm_read = statm->Read(buffer, statm_length);
   if (statm_read <= 0) {
     return -1;
   }
   int64_t current_rss_pages = 0;
   int matches = sscanf(reinterpret_cast<char*>(buffer), "%*s%" Pd64 "",
                        &current_rss_pages);
   if (matches != 1) {
     return -1;
   }
   return current_rss_pages * getpagesize();
 }
 
-
 int64_t Process::MaxRSS() {
   struct rusage usage;
   usage.ru_maxrss = 0;
   int r = getrusage(RUSAGE_SELF, &usage);
   if (r < 0) {
     return -1;
   }
   return usage.ru_maxrss * KB;
 }
 
-
 static Mutex* signal_mutex = new Mutex();
 static SignalInfo* signal_handlers = NULL;
 static const int kSignalsCount = 7;
 static const int kSignals[kSignalsCount] = {
     SIGHUP, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, SIGWINCH,
     SIGQUIT  // Allow VMService to listen on SIGQUIT.
 };
 
-
 SignalInfo::~SignalInfo() {
   VOID_TEMP_FAILURE_RETRY(close(fd_));
 }
 
-
 static void SignalHandler(int signal) {
   MutexLocker lock(signal_mutex);
   const SignalInfo* handler = signal_handlers;
   while (handler != NULL) {
     if (handler->signal() == signal) {
       int value = 0;
       VOID_TEMP_FAILURE_RETRY(write(handler->fd(), &value, 1));
     }
     handler = handler->next();
   }
 }
 
-
 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;
@@ skipping 30 matching lines @@
     if (status < 0) {
       VOID_TEMP_FAILURE_RETRY(close(fds[0]));
       VOID_TEMP_FAILURE_RETRY(close(fds[1]));
       return -1;
     }
   }
   signal_handlers = new SignalInfo(fds[1], signal, signal_handlers);
   return fds[0];
 }
 
-
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {
   // Either the port is illegal or there is no current isolate, but not both.
   ASSERT((port != ILLEGAL_PORT) || (Dart_CurrentIsolate() == NULL));
   ASSERT((port == ILLEGAL_PORT) || (Dart_CurrentIsolate() != NULL));
   ThreadSignalBlocker blocker(kSignalsCount, kSignals);
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;
   bool unlisten = true;
   while (handler != NULL) {
     bool remove = false;
@@ skipping 21 matching lines @@
     VOID_NO_RETRY_EXPECTED(sigaction(signal, &act, NULL));
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_ANDROID)
 
 #endif  // !defined(DART_IO_DISABLED)