clang-format runtime/bin

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(TARGET_OS_WINDOWS)
 
 #include "bin/process.h"
@@ skipping 27 matching lines @@
 // ProcessInfoList.
 class ProcessInfo {
  public:
   ProcessInfo(DWORD process_id,
               HANDLE process_handle,
               HANDLE wait_handle,
               HANDLE exit_pipe)
       : process_id_(process_id),
         process_handle_(process_handle),
         wait_handle_(wait_handle),
-        exit_pipe_(exit_pipe) { }
+        exit_pipe_(exit_pipe) {}
 
   ~ProcessInfo() {
     BOOL success = CloseHandle(process_handle_);
     if (!success) {
       FATAL("Failed to close process handle");
     }
     success = CloseHandle(exit_pipe_);
     if (!success) {
       FATAL("Failed to close process exit code pipe");
     }
@@ skipping 28 matching lines @@
 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_);
     HANDLE wait_handle = INVALID_HANDLE_VALUE;
     BOOL success = RegisterWaitForSingleObject(
-        &wait_handle,
-        handle,
-        &ExitCodeCallback,
-        reinterpret_cast<void*>(pid),
-        INFINITE,
-        WT_EXECUTEONLYONCE);
+        &wait_handle, handle, &ExitCodeCallback, reinterpret_cast<void*>(pid),
+        INFINITE, WT_EXECUTEONLYONCE);
     if (!success) {
       FATAL("Failed to register exit code wait operation.");
     }
     ProcessInfo* info = new ProcessInfo(pid, handle, wait_handle, pipe);
     // Mutate the process list under the mutex.
     info->set_next(active_processes_);
     active_processes_ = info;
   }
 
   static bool LookupProcess(DWORD pid,
@@ skipping 57 matching lines @@
     int exit_code;
     ok = GetExitCodeProcess(handle, reinterpret_cast<DWORD*>(&exit_code));
     if (!ok) {
       FATAL1("GetExitCodeProcess failed %d\n", GetLastError());
     }
     int negative = 0;
     if (exit_code < 0) {
       exit_code = abs(exit_code);
       negative = 1;
     }
-    int message[2] = { exit_code, negative };
+    int message[2] = {exit_code, negative};
     DWORD written;
     ok = WriteFile(exit_pipe, message, sizeof(message), &written, NULL);
     // If the process has been closed, the read end of the exit
     // pipe has been closed. It is therefore not a problem that
     // WriteFile fails with a closed pipe error
     // (ERROR_NO_DATA). Other errors should not happen.
     if (ok && (written != sizeof(message))) {
       FATAL("Failed to write entire process exit message");
     } else if (!ok && (GetLastError() != ERROR_NO_DATA)) {
       FATAL1("Failed to write exit code: %d", GetLastError());
@@ skipping 12 matching lines @@
   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
-};
+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;
   inherit_handle.nLength = sizeof(SECURITY_ATTRIBUTES);
   inherit_handle.bInheritHandle = TRUE;
   inherit_handle.lpSecurityDescriptor = NULL;
 
   if (type == kInheritRead) {
     handles[kWriteHandle] =
-        CreateNamedPipeW(pipe_name,
-                         PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
+        CreateNamedPipeW(pipe_name, PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
                          PIPE_TYPE_BYTE | PIPE_WAIT,
-                         1,             // Number of pipes
-                         1024,          // Out buffer size
-                         1024,          // In buffer size
-                         0,             // Timeout in ms
+                         1,     // Number of pipes
+                         1024,  // Out buffer size
+                         1024,  // In buffer size
+                         0,     // Timeout in ms
                          NULL);
 
     if (handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateNamedPipe failed %d\n", GetLastError());
       return false;
     }
 
     handles[kReadHandle] =
-        CreateFileW(pipe_name,
-                    GENERIC_READ,
-                    0,
-                    &inherit_handle,
-                    OPEN_EXISTING,
-                    FILE_READ_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
-                    NULL);
+        CreateFileW(pipe_name, GENERIC_READ, 0, &inherit_handle, OPEN_EXISTING,
+                    FILE_READ_ATTRIBUTES | FILE_FLAG_OVERLAPPED, NULL);
     if (handles[kReadHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateFile failed %d\n", GetLastError());
       return false;
     }
   } else {
     ASSERT((type == kInheritWrite) || (type == kInheritNone));
     handles[kReadHandle] =
-        CreateNamedPipeW(pipe_name,
-                         PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+        CreateNamedPipeW(pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
                          PIPE_TYPE_BYTE | PIPE_WAIT,
-                         1,             // Number of pipes
-                         1024,          // Out buffer size
-                         1024,          // In buffer size
-                         0,             // Timeout in ms
+                         1,     // Number of pipes
+                         1024,  // Out buffer size
+                         1024,  // In buffer size
+                         0,     // Timeout in ms
                          NULL);
 
     if (handles[kReadHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateNamedPipe failed %d\n", GetLastError());
       return false;
     }
 
-    handles[kWriteHandle] =
-        CreateFileW(pipe_name,
-                    GENERIC_WRITE,
-                    0,
-                    (type == kInheritWrite) ? &inherit_handle : NULL,
-                    OPEN_EXISTING,
-                    FILE_WRITE_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
-                    NULL);
+    handles[kWriteHandle] = CreateFileW(
+        pipe_name, GENERIC_WRITE, 0,
+        (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]) {
@@ skipping 28 matching lines @@
   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);
+  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* 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 BOOL(WINAPI* UpdateProcThreadAttrFn)(LPPROC_THREAD_ATTRIBUTE_LIST,
+                                             DWORD,
+                                             DWORD_PTR,
+                                             PVOID,
+                                             SIZE_T,
+                                             PVOID,
+                                             PSIZE_T);
 
-typedef VOID (WINAPI *DeleteProcThreadAttrListFn)(
-     LPPROC_THREAD_ATTRIBUTE_LIST);
+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();
@@ skipping 10 matching lines @@
     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>
+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);
+    _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 {
@@ skipping 28 matching lines @@
     stderr_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
     exit_handles_[kReadHandle] = INVALID_HANDLE_VALUE;
     exit_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
 
     // Transform input strings to system format.
     const wchar_t* system_path = StringUtilsWin::Utf8ToWide(path_);
     wchar_t** system_arguments;
     system_arguments = reinterpret_cast<wchar_t**>(
         Dart_ScopeAllocate(arguments_length * sizeof(*system_arguments)));
     for (int i = 0; i < arguments_length; i++) {
-       system_arguments[i] = StringUtilsWin::Utf8ToWide(arguments[i]);
+      system_arguments[i] = StringUtilsWin::Utf8ToWide(arguments[i]);
     }
 
     // Compute command-line length.
     int command_line_length = wcslen(system_path);
     for (int i = 0; i < arguments_length; i++) {
       command_line_length += wcslen(system_arguments[i]);
     }
     // Account for null termination and one space per argument.
     command_line_length += arguments_length + 1;
 
     // Put together command-line string.
-    command_line_ = reinterpret_cast<wchar_t*>(Dart_ScopeAllocate(
-        command_line_length * sizeof(*command_line_)));
+    command_line_ = reinterpret_cast<wchar_t*>(
+        Dart_ScopeAllocate(command_line_length * sizeof(*command_line_)));
     int len = 0;
     int remaining = command_line_length;
     int written =
         _snwprintf(command_line_ + len, remaining, L"%s", system_path);
     len += written;
     remaining -= written;
     ASSERT(remaining >= 0);
     for (int i = 0; i < arguments_length; i++) {
-      written = _snwprintf(
-          command_line_ + len, remaining, L" %s", system_arguments[i]);
+      written = _snwprintf(command_line_ + len, remaining, L" %s",
+                           system_arguments[i]);
       len += written;
       remaining -= written;
       ASSERT(remaining >= 0);
     }
 
     // Create environment block if an environment is supplied.
     environment_block_ = NULL;
     if (environment != NULL) {
       wchar_t** system_environment;
       system_environment = reinterpret_cast<wchar_t**>(
           Dart_ScopeAllocate(environment_length * sizeof(*system_environment)));
       // Convert environment strings to system strings.
       for (intptr_t i = 0; i < environment_length; i++) {
         system_environment[i] = StringUtilsWin::Utf8ToWide(environment[i]);
       }
 
       // An environment block is a sequence of zero-terminated strings
       // followed by a block-terminating zero char.
       intptr_t block_size = 1;
       for (intptr_t i = 0; i < environment_length; i++) {
         block_size += wcslen(system_environment[i]) + 1;
       }
-      environment_block_ = reinterpret_cast<wchar_t*>(Dart_ScopeAllocate(
-          block_size * sizeof(*environment_block_)));
+      environment_block_ = reinterpret_cast<wchar_t*>(
+          Dart_ScopeAllocate(block_size * sizeof(*environment_block_)));
       intptr_t block_index = 0;
       for (intptr_t i = 0; i < environment_length; i++) {
         intptr_t len = wcslen(system_environment[i]);
-        intptr_t result = _snwprintf(environment_block_ + block_index,
-                                     len,
-                                     L"%s",
-                                     system_environment[i]);
+        intptr_t result = _snwprintf(environment_block_ + block_index, len,
+                                     L"%s", system_environment[i]);
         ASSERT(result == len);
         block_index += len;
         environment_block_[block_index++] = '\0';
       }
       // Block-terminating zero char.
       environment_block_[block_index++] = '\0';
       ASSERT(block_index == block_size);
     }
 
     system_working_directory_ = NULL;
@@ skipping 40 matching lines @@
           (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
         return CleanupAndReturnError();
       }
       attribute_list_ = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(
           Dart_ScopeAllocate(size));
       ZeroMemory(attribute_list_, size);
       if (!init_proc_thread_attr_list(attribute_list_, 1, 0, &size)) {
         return CleanupAndReturnError();
       }
       static const int kNumInheritedHandles = 3;
-      HANDLE inherited_handles[kNumInheritedHandles] =
-          { stdin_handles_[kReadHandle],
-            stdout_handles_[kWriteHandle],
-            stderr_handles_[kWriteHandle] };
-      if (!update_proc_thread_attr(attribute_list_,
-                                   0,
-                                   PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
-                                   inherited_handles,
-                                   kNumInheritedHandles * sizeof(HANDLE),
-                                   NULL,
-                                   NULL)) {
+      HANDLE inherited_handles[kNumInheritedHandles] = {
+          stdin_handles_[kReadHandle], stdout_handles_[kWriteHandle],
+          stderr_handles_[kWriteHandle]};
+      if (!update_proc_thread_attr(
+              attribute_list_, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
+              inherited_handles, kNumInheritedHandles * sizeof(HANDLE), NULL,
+              NULL)) {
         return CleanupAndReturnError();
       }
       startup_info.lpAttributeList = attribute_list_;
     }
 
     PROCESS_INFORMATION process_info;
     ZeroMemory(&process_info, sizeof(process_info));
 
     // Create process.
     DWORD creation_flags =
         EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT;
     if (mode_ != kNormal) {
       creation_flags |= DETACHED_PROCESS;
     }
-    BOOL result = CreateProcessW(NULL,   // ApplicationName
-                                 command_line_,
-                                 NULL,   // ProcessAttributes
-                                 NULL,   // ThreadAttributes
-                                 TRUE,   // InheritHandles
-                                 creation_flags,
-                                 environment_block_,
-                                 system_working_directory_,
-                                 reinterpret_cast<STARTUPINFOW*>(&startup_info),
-                                 &process_info);
+    BOOL result = CreateProcessW(
+        NULL,  // ApplicationName
+        command_line_,
+        NULL,  // ProcessAttributes
+        NULL,  // ThreadAttributes
+        TRUE,  // InheritHandles
+        creation_flags, environment_block_, system_working_directory_,
+        reinterpret_cast<STARTUPINFOW*>(&startup_info), &process_info);
 
     if (result == 0) {
       return CleanupAndReturnError();
     }
 
     CloseHandle(stdin_handles_[kReadHandle]);
     CloseHandle(stdout_handles_[kWriteHandle]);
     CloseHandle(stderr_handles_[kWriteHandle]);
     if (mode_ == kNormal) {
       ProcessInfoList::AddProcess(process_info.dwProcessId,
@@ skipping 62 matching lines @@
       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_);
+    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_;
@@ skipping 23 matching lines @@
                    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);
+  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 {
+class BufferList : public BufferListBase {
  public:
-  BufferList() : read_pending_(true) { }
+  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);
     data_size_ += size;
     free_size_ -= size;
     ASSERT(free_size_ >= 0);
     read_pending_ = false;
   }
 
   // The access to the read buffer for overlapped read.
   void GetReadBuffer(uint8_t** buffer, intptr_t* size) {
     ASSERT(!read_pending_);
     if (free_size_ == 0) {
       Allocate();
     }
     ASSERT(free_size_ > 0);
     ASSERT(free_size_ <= kBufferSize);
     *buffer = FreeSpaceAddress();
     *size = free_size_;
     read_pending_ = true;
   }
 
-  intptr_t GetDataSize() {
-    return data_size_;
-  }
+  intptr_t GetDataSize() { return data_size_; }
 
   uint8_t* GetFirstDataBuffer() {
     ASSERT(head_ != NULL);
     ASSERT(head_ == tail_);
     ASSERT(data_size_ <= kBufferSize);
     return head_->data_;
   }
 
-  void FreeDataBuffer() {
-    Free();
-  }
+  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();
   }
 
-  bool HasEvent(HANDLE event) {
-    return (event_ == event);
-  }
+  bool HasEvent(HANDLE event) { return (event_ == event); }
 
   bool Read() {
     // Get the data read as a result of a completed overlapped operation.
     if (overlapped_.InternalHigh > 0) {
       buffer_.DataIsRead(overlapped_.InternalHigh);
     } else {
       buffer_.DataIsRead(0);
     }
 
     // Keep reading until error or pending operation.
     while (true) {
       ClearOverlapped();
       uint8_t* buffer;
       intptr_t buffer_size;
       buffer_.GetReadBuffer(&buffer, &buffer_size);
       BOOL ok = ReadFile(handle_, buffer, buffer_size, NULL, &overlapped_);
       if (!ok) {
         return (GetLastError() == ERROR_IO_PENDING);
       }
       buffer_.DataIsRead(overlapped_.InternalHigh);
     }
   }
 
-  Dart_Handle GetData() {
-    return buffer_.GetData();
-  }
+  Dart_Handle GetData() { return buffer_.GetData(); }
 
-  intptr_t GetDataSize() {
-    return buffer_.GetDataSize();
-  }
+  intptr_t GetDataSize() { return buffer_.GetDataSize(); }
 
-  uint8_t* GetFirstDataBuffer() {
-    return buffer_.GetFirstDataBuffer();
-  }
+  uint8_t* GetFirstDataBuffer() { return buffer_.GetFirstDataBuffer(); }
 
-  void FreeDataBuffer() {
-    return buffer_.FreeDataBuffer();
-  }
+  void FreeDataBuffer() { return buffer_.FreeDataBuffer(); }
 
   void Close() {
     CloseHandle(handle_);
     CloseHandle(event_);
     handle_ = INVALID_HANDLE_VALUE;
     overlapped_.hEvent = INVALID_HANDLE_VALUE;
   }
 
  private:
   void ClearOverlapped() {
@@ skipping 92 matching lines @@
   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);
+  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);
@@ skipping 31 matching lines @@
       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;
+    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) {
     return -1;
@@ skipping 56 matching lines @@
   }
   delete handler;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)