Remove static mutexes/monitors from dart:io.

runtime/bin/process_linux.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_LINUX)
 
 #include "bin/process.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 39 matching lines @@
   intptr_t fd_;
   ProcessInfo* next_;
 };
 
 
 // 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_);
+    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_);
+    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_);
+    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;
         return;
       }
       prev = current;
       current = current->next();
     }
   }
 
  private:
   // 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();
 
 
 // The exit code handler sets up a separate thread which is signalled
 // on SIGCHLD. 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:
   // Ensure that the ExitCodeHandler has been initialized.
   static bool EnsureInitialized() {
     // Multiple isolates could be starting processes at the same
     // time. Make sure that only one of them initializes the
     // ExitCodeHandler.
-    MutexLocker locker(&mutex_);
+    MutexLocker locker(mutex_);
     if (initialized_) {
       return true;
     }
 
     // Allocate a pipe that the signal handler can write a byte to and
     // that the exit handler thread can poll.
     int result = TEMP_FAILURE_RETRY(pipe(sig_chld_fds_));
     if (result < 0) {
       return false;
     }
@@ skipping 15 matching lines @@
     return true;
   }
 
   // Get the write end of the pipe.
   static int WakeUpFd() {
     ASSERT(initialized_);
     return sig_chld_fds_[1];
   }
 
   static void TerminateExitCodeThread() {
-    MutexLocker locker(&mutex_);
+    MutexLocker locker(mutex_);
     if (!initialized_) {
       return;
     }
 
     uint8_t data = kThreadTerminateByte;
     ssize_t result =
         TEMP_FAILURE_RETRY(write(ExitCodeHandler::WakeUpFd(), &data, 1));
     if (result < 1) {
       perror("Failed to write to wake-up fd to terminate exit code thread");
     }
 
     {
-      MonitorLocker terminate_locker(&thread_terminate_monitor_);
+      MonitorLocker terminate_locker(thread_terminate_monitor_);
       while (!thread_terminated_) {
         terminate_locker.Wait();
       }
     }
   }
 
   static void ExitCodeThreadTerminated() {
-    MonitorLocker locker(&thread_terminate_monitor_);
+    MonitorLocker locker(thread_terminate_monitor_);
     thread_terminated_ = true;
     locker.Notify();
   }
 
  private:
   static const uint8_t kThreadTerminateByte = 1;
 
   // GetProcessExitCodes is called on a separate thread when a SIGCHLD
   // signal is received to retrieve the exit codes and post them to
   // dart.
@@ skipping 54 matching lines @@
         if (data == ExitCodeHandler::kThreadTerminateByte) {
           ExitCodeThreadTerminated();
           return;
         }
         // Get the exit code from all processes that have died.
         GetProcessExitCodes();
       }
     }
   }
 
-  static dart::Mutex mutex_;
+  static dart::Mutex* mutex_;
   static bool initialized_;
   static int sig_chld_fds_[2];
   static bool thread_terminated_;
-  static dart::Monitor thread_terminate_monitor_;
+  static dart::Monitor* thread_terminate_monitor_;
 };
 
 
-dart::Mutex ExitCodeHandler::mutex_;
+dart::Mutex* ExitCodeHandler::mutex_ = new dart::Mutex();
 bool ExitCodeHandler::initialized_ = false;
 int ExitCodeHandler::sig_chld_fds_[2] = { 0, 0 };
 bool ExitCodeHandler::thread_terminated_ = false;
-dart::Monitor ExitCodeHandler::thread_terminate_monitor_;
+dart::Monitor* ExitCodeHandler::thread_terminate_monitor_ = new dart::Monitor();
 
 
 static void SetChildOsErrorMessage(char** os_error_message) {
   *os_error_message = strdup(strerror(errno));
 }
 
 
 static void SigChldHandler(int process_signal, siginfo_t* siginfo, void* tmp) {
   // Save errno so it can be restored at the end.
   int entry_errno = errno;
@@ skipping 296 matching lines @@
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(getpid());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)