- Make sure that the threads for dart::bin are in the correct namespace.

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 86 matching lines @@
       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 Mutex* mutex_;
 };
 
 
 ProcessInfo* ProcessInfoList::active_processes_ = NULL;
-dart::Mutex* ProcessInfoList::mutex_ = new dart::Mutex();
+Mutex* ProcessInfoList::mutex_ = new Mutex();
 
 
 // The exit code handler sets up a separate thread which waits for child
 // processes to terminate. 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:
   // Notify the ExitCodeHandler that another process exists.
   static void ProcessStarted() {
     // Multiple isolates could be starting processes at the same
     // time. Make sure that only one ExitCodeHandler thread exists.
     MonitorLocker locker(monitor_);
     process_count_++;
 
     monitor_->Notify();
 
     if (running_) {
       return;
     }
 
     // Start thread that handles process exits when wait returns.
-    int result = dart::Thread::Start(ExitCodeHandlerEntry, 0);
+    int result = Thread::Start(ExitCodeHandlerEntry, 0);
     if (result != 0) {
       FATAL1("Failed to start exit code handler worker thread %d", result);
     }
 
     running_ = true;
   }
 
   static void TerminateExitCodeThread() {
     MonitorLocker locker(monitor_);
 
     if (!running_) {
       return;
     }
 
     // Set terminate_done_ to false, so we can use it as a guard for our
     // monitor.
     running_ = false;
 
     // Fork to wake up waitpid.
     if (TEMP_FAILURE_RETRY(fork()) == 0) {
       exit(0);
     }
 
     monitor_->Notify();
 
     while (!terminate_done_) {
-      monitor_->Wait(dart::Monitor::kNoTimeout);
+      monitor_->Wait(Monitor::kNoTimeout);
     }
   }
 
  private:
   // Entry point for the separate exit code handler thread started by
   // the ExitCodeHandler.
   static void ExitCodeHandlerEntry(uword param) {
     pid_t pid = 0;
     int status = 0;
     while (true) {
       {
         MonitorLocker locker(monitor_);
         while (running_ && process_count_ == 0) {
-          monitor_->Wait(dart::Monitor::kNoTimeout);
+          monitor_->Wait(Monitor::kNoTimeout);
         }
         if (!running_) {
           terminate_done_ = true;
           monitor_->Notify();
           return;
         }
       }
 
       if ((pid = TEMP_FAILURE_RETRY(wait(&status))) > 0) {
         int exit_code = 0;
@@ skipping 25 matching lines @@
             process_count_--;
           }
         }
       }
     }
   }
 
   static bool terminate_done_;
   static int process_count_;
   static bool running_;
-  static dart::Monitor* monitor_;
+  static Monitor* monitor_;
 };
 
 
 bool ExitCodeHandler::running_ = false;
 int ExitCodeHandler::process_count_ = 0;
 bool ExitCodeHandler::terminate_done_ = false;
-dart::Monitor* ExitCodeHandler::monitor_ = new dart::Monitor();
+Monitor* ExitCodeHandler::monitor_ = new Monitor();
 
 
 static void SetChildOsErrorMessage(char** os_error_message) {
   const int kBufferSize = 1024;
   char error_buf[kBufferSize];
   *os_error_message = strdup(strerror_r(errno, error_buf, kBufferSize));
 }
 
 
 static void ReportChildError(int exec_control_fd) {
@@ skipping 494 matching lines @@
     bzero(&act, sizeof(act));
     act.sa_handler = SIG_DFL;
     sigaction(signal, &act, NULL);
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)