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

runtime/bin/process_win.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_WINDOWS)
 
 #include "bin/process.h"
 
+#include <process.h>  // NOLINT
 #include <psapi.h>    // NOLINT
-#include <process.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/utils_win.h"
@@ skipping 51 matching lines @@
   // with RegisterWaitForSingleObject.
   HANDLE wait_handle_;
   // File descriptor for pipe to report exit code.
   HANDLE exit_pipe_;
   // Link to next ProcessInfo object in the singly-linked list.
   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(DWORD pid, HANDLE handle, HANDLE pipe) {
     // Register a callback to extract the exit code, when the process
     // is signaled.  The callback runs in a independent thread from the OS pool.
     // Because the callback depends on the process list containing
     // the process, lock the mutex until the process is added to the list.
     MutexLocker locker(mutex_);
@@ skipping 98 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();
 
-
 // Types of pipes to create.
 enum NamedPipeType { kInheritRead, kInheritWrite, kInheritNone };
 
-
 // Create a pipe for communicating with a new process. The handles array
 // will contain the read and write ends of the pipe. Based on the type
 // one of the handles will be inheritable.
 // NOTE: If this function returns false the handles might have been allocated
 // and the caller should make sure to close them in case of an error.
 static bool CreateProcessPipe(HANDLE handles[2],
                               wchar_t* pipe_name,
                               NamedPipeType type) {
   // Security attributes describing an inheritable handle.
   SECURITY_ATTRIBUTES inherit_handle;
@@ skipping 44 matching lines @@
         (type == kInheritWrite) ? &inherit_handle : NULL, OPEN_EXISTING,
         FILE_WRITE_ATTRIBUTES | FILE_FLAG_OVERLAPPED, NULL);
     if (handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateFile failed %d\n", GetLastError());
       return false;
     }
   }
   return true;
 }
 
-
 static void CloseProcessPipe(HANDLE handles[2]) {
   for (int i = kReadHandle; i < kWriteHandle; i++) {
     if (handles[i] != INVALID_HANDLE_VALUE) {
       if (!CloseHandle(handles[i])) {
         Log::PrintErr("CloseHandle failed %d\n", GetLastError());
       }
       handles[i] = INVALID_HANDLE_VALUE;
     }
   }
 }
 
-
 static void CloseProcessPipes(HANDLE handles1[2],
                               HANDLE handles2[2],
                               HANDLE handles3[2],
                               HANDLE handles4[2]) {
   CloseProcessPipe(handles1);
   CloseProcessPipe(handles2);
   CloseProcessPipe(handles3);
   CloseProcessPipe(handles4);
 }
 
-
 static int SetOsErrorMessage(char** os_error_message) {
   int error_code = GetLastError();
   const int kMaxMessageLength = 256;
   wchar_t message[kMaxMessageLength];
   FormatMessageIntoBuffer(error_code, message, kMaxMessageLength);
   *os_error_message = StringUtilsWin::WideToUtf8(message);
   return error_code;
 }
 
-
 // Open an inheritable handle to NUL.
 static HANDLE OpenNul() {
   SECURITY_ATTRIBUTES inherit_handle;
   inherit_handle.nLength = sizeof(SECURITY_ATTRIBUTES);
   inherit_handle.bInheritHandle = TRUE;
   inherit_handle.lpSecurityDescriptor = NULL;
   HANDLE nul = CreateFile(L"NUL", GENERIC_READ | GENERIC_WRITE, 0,
                           &inherit_handle, OPEN_EXISTING, 0, NULL);
   if (nul == INVALID_HANDLE_VALUE) {
     Log::PrintErr("CloseHandle failed %d\n", GetLastError());
   }
   return nul;
 }
 
-
 typedef BOOL(WINAPI* InitProcThreadAttrListFn)(LPPROC_THREAD_ATTRIBUTE_LIST,
                                                DWORD,
                                                DWORD,
                                                PSIZE_T);
 
 typedef BOOL(WINAPI* UpdateProcThreadAttrFn)(LPPROC_THREAD_ATTRIBUTE_LIST,
                                              DWORD,
                                              DWORD_PTR,
                                              PVOID,
                                              SIZE_T,
                                              PVOID,
                                              PSIZE_T);
 
 typedef VOID(WINAPI* DeleteProcThreadAttrListFn)(LPPROC_THREAD_ATTRIBUTE_LIST);
 
-
 static InitProcThreadAttrListFn init_proc_thread_attr_list = NULL;
 static UpdateProcThreadAttrFn update_proc_thread_attr = NULL;
 static DeleteProcThreadAttrListFn delete_proc_thread_attr_list = NULL;
 
-
 static bool EnsureInitialized() {
   static bool load_attempted = false;
   static Mutex* mutex = new Mutex();
   HMODULE kernel32_module = GetModuleHandleW(L"kernel32.dll");
   if (!load_attempted) {
     MutexLocker locker(mutex);
     if (load_attempted) {
       return (delete_proc_thread_attr_list != NULL);
     }
     init_proc_thread_attr_list = reinterpret_cast<InitProcThreadAttrListFn>(
         GetProcAddress(kernel32_module, "InitializeProcThreadAttributeList"));
     update_proc_thread_attr = reinterpret_cast<UpdateProcThreadAttrFn>(
         GetProcAddress(kernel32_module, "UpdateProcThreadAttribute"));
     delete_proc_thread_attr_list = reinterpret_cast<DeleteProcThreadAttrListFn>(
         GetProcAddress(kernel32_module, "DeleteProcThreadAttributeList"));
     load_attempted = true;
     return (delete_proc_thread_attr_list != NULL);
   }
   return (delete_proc_thread_attr_list != NULL);
 }
 
-
 const int kMaxPipeNameSize = 80;
 template <int Count>
 static int GenerateNames(wchar_t pipe_names[Count][kMaxPipeNameSize]) {
   UUID uuid;
   RPC_STATUS status = UuidCreateSequential(&uuid);
   if ((status != RPC_S_OK) && (status != RPC_S_UUID_LOCAL_ONLY)) {
     return status;
   }
   RPC_WSTR uuid_string;
   status = UuidToStringW(&uuid, &uuid_string);
   if (status != RPC_S_OK) {
     return status;
   }
   for (int i = 0; i < Count; i++) {
     static const wchar_t* prefix = L"\\\\.\\Pipe\\dart";
     _snwprintf(pipe_names[i], kMaxPipeNameSize, L"%s_%s_%d", prefix,
                uuid_string, i + 1);
   }
   status = RpcStringFreeW(&uuid_string);
   if (status != RPC_S_OK) {
     return status;
   }
   return 0;
 }
 
-
 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 90 matching lines @@
 
     system_working_directory_ = NULL;
     if (working_directory_ != NULL) {
       system_working_directory_ =
           StringUtilsWin::Utf8ToWide(working_directory_);
     }
 
     attribute_list_ = NULL;
   }
 
-
   ~ProcessStarter() {
     if (attribute_list_ != NULL) {
       delete_proc_thread_attr_list(attribute_list_);
     }
   }
 
-
   int Start() {
     // Create pipes required.
     int err = CreatePipes();
     if (err != 0) {
       return err;
     }
 
     // Setup info structures.
     STARTUPINFOEXW startup_info;
     ZeroMemory(&startup_info, sizeof(startup_info));
@@ skipping 77 matching lines @@
       }
     }
 
     CloseHandle(process_info.hThread);
 
     // Return process id.
     *id_ = process_info.dwProcessId;
     return 0;
   }
 
-
   int CreatePipes() {
     // Generate unique pipe names for the four named pipes needed.
     wchar_t pipe_names[4][kMaxPipeNameSize];
     int status = GenerateNames<4>(pipe_names);
     if (status != 0) {
       SetOsErrorMessage(os_error_message_);
       Log::PrintErr("UuidCreateSequential failed %d\n", status);
       return status;
     }
 
@@ skipping 24 matching lines @@
       }
 
       stderr_handles_[kWriteHandle] = OpenNul();
       if (stderr_handles_[kWriteHandle] == INVALID_HANDLE_VALUE) {
         return CleanupAndReturnError();
       }
     }
     return 0;
   }
 
-
   int CleanupAndReturnError() {
     int error_code = SetOsErrorMessage(os_error_message_);
     CloseProcessPipes(stdin_handles_, stdout_handles_, stderr_handles_,
                       exit_handles_);
     return error_code;
   }
 
-
   HANDLE stdin_handles_[2];
   HANDLE stdout_handles_[2];
   HANDLE stderr_handles_[2];
   HANDLE exit_handles_[2];
 
   const wchar_t* system_working_directory_;
   wchar_t* command_line_;
   wchar_t* environment_block_;
   LPPROC_THREAD_ATTRIBUTE_LIST attribute_list_;
 
   const char* path_;
   const char* working_directory_;
   ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_handler_;
   char** os_error_message_;
 
  private:
   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_handler,
                    char** os_error_message) {
   ProcessStarter starter(path, arguments, arguments_length, working_directory,
                          environment, environment_length, mode, in, out, err,
                          id, exit_handler, os_error_message);
   return starter.Start();
 }
 
-
 class BufferList : public BufferListBase {
  public:
   BufferList() : read_pending_(true) {}
 
   // Indicate that data has been read into the buffer provided to
   // overlapped read.
   void DataIsRead(intptr_t size) {
     ASSERT(read_pending_ == true);
     set_data_size(data_size() + size);
     set_free_size(free_size() - size);
@@ skipping 27 matching lines @@
   }
 
   void FreeDataBuffer() { Free(); }
 
  private:
   bool read_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferList);
 };
 
-
 class OverlappedHandle {
  public:
   OverlappedHandle() {}
 
   void Init(HANDLE handle, HANDLE event) {
     handle_ = handle;
     event_ = event;
     ClearOverlapped();
   }
 
@@ skipping 50 matching lines @@
 
   OVERLAPPED overlapped_;
   HANDLE handle_;
   HANDLE event_;
   BufferList buffer_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(OverlappedHandle);
 };
 
-
 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.
   reinterpret_cast<FileHandle*>(in)->Close();
 
   // All pipes created to the sub-process support overlapped IO.
@@ skipping 63 matching lines @@
   oh[2].FreeDataBuffer();
   intptr_t exit_code = exit_codes[0];
   intptr_t negative = exit_codes[1];
   if (negative != 0) {
     exit_code = -exit_code;
   }
   result->set_exit_code(exit_code);
   return true;
 }
 
-
 bool Process::Kill(intptr_t id, int signal) {
   USE(signal);  // signal is not used on Windows.
   HANDLE process_handle;
   HANDLE wait_handle;
   HANDLE exit_pipe;
   // First check the process info list for the process to get a handle to it.
   bool success = ProcessInfoList::LookupProcess(id, &process_handle,
                                                 &wait_handle, &exit_pipe);
   // For detached processes we don't have the process registered in the
   // process info list. Try to look it up through the OS.
   if (!success) {
     process_handle = OpenProcess(PROCESS_TERMINATE, FALSE, id);
     // The process is already dead.
     if (process_handle == INVALID_HANDLE_VALUE) {
       return false;
     }
   }
   BOOL result = TerminateProcess(process_handle, -1);
   return result ? true : false;
 }
 
-
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
-
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }
 
-
 int64_t Process::CurrentRSS() {
   PROCESS_MEMORY_COUNTERS pmc;
   if (!GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
     return -1;
   }
   return pmc.WorkingSetSize;
 }
 
-
 int64_t Process::MaxRSS() {
   PROCESS_MEMORY_COUNTERS pmc;
   if (!GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) {
     return -1;
   }
   return pmc.PeakWorkingSetSize;
 }
 
-
 static SignalInfo* signal_handlers = NULL;
 static Mutex* signal_mutex = new Mutex();
 
-
 SignalInfo::~SignalInfo() {
   FileHandle* file_handle = reinterpret_cast<FileHandle*>(fd_);
   file_handle->Close();
   file_handle->Release();
 }
 
-
 BOOL WINAPI SignalHandler(DWORD signal) {
   MutexLocker lock(signal_mutex);
   const SignalInfo* handler = signal_handlers;
   bool handled = false;
   while (handler != NULL) {
     if (handler->signal() == signal) {
       int value = 0;
       SocketBase::Write(handler->fd(), &value, 1, SocketBase::kAsync);
       handled = true;
     }
     handler = handler->next();
   }
   return handled;
 }
 
-
 intptr_t GetWinSignal(intptr_t signal) {
   switch (signal) {
     case kSighup:
       return CTRL_CLOSE_EVENT;
     case kSigint:
       return CTRL_C_EVENT;
     default:
       return -1;
   }
 }
 
-
 intptr_t Process::SetSignalHandler(intptr_t signal) {
   signal = GetWinSignal(signal);
   if (signal == -1) {
     SetLastError(ERROR_NOT_SUPPORTED);
     return -1;
   }
 
   // Generate a unique pipe name for the named pipe.
   wchar_t pipe_name[kMaxPipeNameSize];
   int status = GenerateNames<1>(&pipe_name);
@@ skipping 23 matching lines @@
       write_handle->Release();
       CloseProcessPipe(fds);
       SetLastError(error_code);
       return -1;
     }
   }
   signal_handlers = new SignalInfo(write_fd, signal, signal_handlers);
   return reinterpret_cast<intptr_t>(new FileHandle(fds[kReadHandle]));
 }
 
-
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {
   signal = GetWinSignal(signal);
   if (signal == -1) {
     return;
   }
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;
   while (handler != NULL) {
     bool remove = false;
     if (handler->signal() == signal) {
@@ skipping 17 matching lines @@
     USE(SetConsoleCtrlHandler(SignalHandler, false));
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)