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

runtime/bin/process_fuchsia.cc

 // Copyright (c) 2016, 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_FUCHSIA)
 
 #include "bin/process.h"
@@ skipping 62 matching lines @@
   void set_next(ProcessInfo* info) { next_ = info; }
 
  private:
   mx_handle_t process_;
   intptr_t exit_pipe_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(mx_handle_t process, intptr_t fd) {
     MutexLocker locker(mutex_);
     ProcessInfo* info = new ProcessInfo(process, fd);
     info->set_next(active_processes_);
     active_processes_ = info;
   }
@@ skipping 327 matching lines @@
 
 bool ExitCodeHandler::do_shutdown_ = false;
 bool ExitCodeHandler::running_ = false;
 bool ExitCodeHandler::terminate_done_ = false;
 Monitor* ExitCodeHandler::monitor_ = new Monitor();
 
 void Process::TerminateExitCodeHandler() {
   ExitCodeHandler::Terminate();
 }
 
-
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(getpid());
 }
 
-
 int64_t Process::CurrentRSS() {
   mx_info_task_stats_t task_stats;
   mx_handle_t process = mx_process_self();
   mx_status_t status = mx_object_get_info(
       process, MX_INFO_TASK_STATS, &task_stats, sizeof(task_stats), NULL, NULL);
   if (status != MX_OK) {
     // TODO(zra): Translate this to a Unix errno.
     errno = status;
     return -1;
   }
   return task_stats.mem_private_bytes + task_stats.mem_shared_bytes;
 }
 
-
 int64_t Process::MaxRSS() {
   // There is currently no way to get the high watermark value on Fuchsia, so
   // just return the current RSS value.
   return CurrentRSS();
 }
 
-
 class IOHandleScope {
  public:
   explicit IOHandleScope(IOHandle* io_handle) : io_handle_(io_handle) {}
   ~IOHandleScope() {
     io_handle_->Close();
     io_handle_->Release();
   }
 
  private:
   IOHandle* io_handle_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(IOHandleScope);
 };
 
-
 bool Process::Wait(intptr_t pid,
                    intptr_t in,
                    intptr_t out,
                    intptr_t err,
                    intptr_t exit_event,
                    ProcessResult* result) {
   // input not needed.
   IOHandle* in_iohandle = reinterpret_cast<IOHandle*>(in);
   in_iohandle->Close();
   in_iohandle->Release();
@@ skipping 122 matching lines @@
     exit_code = -exit_code;
   }
   result->set_exit_code(exit_code);
 
   // Close the process handle.
   mx_handle_t process = static_cast<mx_handle_t>(pid);
   mx_handle_close(process);
   return true;
 }
 
-
 bool Process::Kill(intptr_t id, int signal) {
   LOG_INFO("Sending signal %d to process with id %ld\n", signal, id);
   // mx_task_kill is definitely going to kill the process.
   if ((signal != SIGTERM) && (signal != SIGKILL)) {
     LOG_ERR("Signal %d not supported\n", signal);
     errno = ENOSYS;
     return false;
   }
   // We can only use mx_task_kill if we know id is a process handle, and we only
   // know that for sure if it's in our list.
   mx_handle_t process = static_cast<mx_handle_t>(id);
   if (!ProcessInfoList::Exists(process)) {
     LOG_ERR("Process %ld wasn't in the ProcessInfoList\n", id);
     errno = ESRCH;  // No such process.
     return false;
   }
   mx_status_t status = mx_task_kill(process);
   if (status != MX_OK) {
     LOG_ERR("mx_task_kill failed: %s\n", mx_status_get_string(status));
     errno = EPERM;  // TODO(zra): Figure out what it really should be.
     return false;
   }
   LOG_INFO("Signal %d sent successfully to process %ld\n", signal, id);
   return true;
 }
 
-
 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 176 matching lines @@
   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,
@@ skipping 17 matching lines @@
 }
 
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {}
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_FUCHSIA)
 
 #endif  // !defined(DART_IO_DISABLED)