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

runtime/bin/dbg_connection.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 "bin/dbg_connection.h"
 #include "bin/dbg_message.h"
 #include "bin/dartutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 
 namespace dart {
 namespace bin {
 
 extern bool trace_debug_protocol;
 
 intptr_t DebuggerConnectionHandler::listener_fd_ = -1;
-dart::Monitor* DebuggerConnectionHandler::handler_lock_ = new dart::Monitor();
+Monitor* DebuggerConnectionHandler::handler_lock_ = new Monitor();
 
 // TODO(asiva): Remove this once we have support for multiple debugger
 // connections. For now we just store the single debugger connection
 // handler in a static variable.
 static DebuggerConnectionHandler* singleton_handler = NULL;
 
 // The maximum message length to print when --trace_debug_protocol is
 // specified.
 static const int kMaxPrintMessageLen = 1024;
 
@@ skipping 301 matching lines @@
 
 void DebuggerConnectionHandler::WaitForConnection() {
   ASSERT(handler_lock_ != NULL);
   MonitorLocker ml(handler_lock_);
   if (!IsListening()) {
     // If we are only running the vm service, don't wait for
     // connections.
     return;
   }
   while (!IsConnected()) {
-    dart::Monitor::WaitResult res = ml.Wait();
-    ASSERT(res == dart::Monitor::kNotified);
+    Monitor::WaitResult res = ml.Wait();
+    ASSERT(res == Monitor::kNotified);
   }
 }
 
 
 void DebuggerConnectionHandler::SendMsg(intptr_t debug_fd,
                                         dart::TextBuffer* msg) {
   ASSERT(handler_lock_ != NULL);
   MonitorLocker ml(handler_lock_);
   SendMsgHelper(debug_fd, msg);
 }
@@ skipping 27 matching lines @@
                ((msg->length() > print_len) ? "..." : ""));
   }
 
   // Sending messages in short pieces can be used to stress test the
   // debugger front-end's message handling code.
   const bool send_in_pieces = false;
   if (send_in_pieces) {
     intptr_t remaining = msg->length();
     intptr_t sent = 0;
     const intptr_t max_piece_len = 122;  // Pretty arbitrary, not a power of 2.
-    dart::Monitor sleep;
+    Monitor sleep;
     while (remaining > 0) {
       intptr_t piece_len = remaining;
       if (piece_len > max_piece_len) {
         piece_len = max_piece_len;
       }
       intptr_t written =
           DebuggerConnectionImpl::Send(debug_fd, msg->buf() + sent, piece_len);
       ASSERT(written == piece_len);
       sent += written;
       remaining -= written;
@@ skipping 91 matching lines @@
 
 
 bool DebuggerConnectionHandler::IsConnected() {
   // TODO(asiva): Support multiple debugger connections.
   // Return true if a connection has been established.
   return singleton_handler != NULL;
 }
 
 }  // namespace bin
 }  // namespace dart