Remove static mutexes/monitors from dart:io.

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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include <process.h>  // NOLINT
 
 #include "bin/builtin.h"
@@ skipping 62 matching lines @@
 
 // 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_);
+    MutexLocker locker(mutex_);
     HANDLE wait_handle = INVALID_HANDLE_VALUE;
     BOOL success = RegisterWaitForSingleObject(
         &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,
                             HANDLE* handle,
                             HANDLE* wait_handle,
                             HANDLE* pipe) {
-    MutexLocker locker(&mutex_);
+    MutexLocker locker(mutex_);
     ProcessInfo* current = active_processes_;
     while (current != NULL) {
       if (current->pid() == pid) {
         *handle = current->process_handle();
         *wait_handle = current->wait_handle();
         *pipe = current->exit_pipe();
         return true;
       }
       current = current->next();
     }
     return false;
   }
 
   static void RemoveProcess(DWORD pid) {
-    MutexLocker locker(&mutex_);
+    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());
         }
         delete current;
@@ skipping 48 matching lines @@
     }
     // Remove the process from the list of active processes.
     RemoveProcess(pid);
   }
 
   // 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 dart::Mutex mutex_;
+  static dart::Mutex* mutex_;
 };
 
 
 ProcessInfo* ProcessInfoList::active_processes_ = NULL;
-dart::Mutex ProcessInfoList::mutex_;
+dart::Mutex* ProcessInfoList::mutex_ = new dart::Mutex();
 
 
 // Types of pipes to create.
 enum NamedPipeType {
   kInheritRead,
   kInheritWrite,
   kInheritNone
 };
 
 
@@ skipping 131 matching lines @@
      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 dart::Mutex mutex;
+  static dart::Mutex* mutex = new dart::Mutex();
   HMODULE kernel32_module = GetModuleHandleW(L"kernel32.dll");
   if (!load_attempted) {
-    MutexLocker locker(&mutex);
+    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>(
         reinterpret_cast<DeleteProcThreadAttrListFn>(
             GetProcAddress(kernel32_module, "DeleteProcThreadAttributeList")));
     load_attempted = true;
@@ skipping 304 matching lines @@
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)