Debugger wire protocol: setting breakpoints

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/dartutils.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/json.h"
 #include "platform/thread.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 
 int DebuggerConnectionHandler::listener_fd_ = -1;
 int DebuggerConnectionHandler::debugger_fd_ = -1;
 dart::Monitor DebuggerConnectionHandler::is_connected_;
 MessageBuffer* DebuggerConnectionHandler::msgbuf_ = NULL;
 
 bool DebuggerConnectionHandler::handler_started_ = false;
 bool DebuggerConnectionHandler::request_resume_ = false;
 
+dart::TextBuffer DebuggerConnectionHandler::queued_messages_(64);
+
 
 // TODO(hausner): Need better error handling.
 #define ASSERT_NOT_ERROR(handle)                                               \
   ASSERT(!Dart_IsError(handle))
 
 typedef void (*CommandHandler)(const char* json_cmd);
 
 struct JSONDebuggerCommand {
   const char* cmd_string;
   CommandHandler handler_function;
@@ skipping 62 matching lines @@
   if (r.Type() == dart::JSONReader::kInteger) {
     return atoi(r.ValueChars());
   } else {
     return -1;
   }
 }
 
 
 const char* MessageBuffer::Params() const {
   dart::JSONReader r(buf_);
-  r.Seek("param");
+  r.Seek("params");
   if (r.Type() == dart::JSONReader::kObject) {
     return r.ValueChars();
   } else {
     return NULL;
   }
 }
 
 
 void MessageBuffer::ReadData() {
   ASSERT(data_length_ >= 0);
@@ skipping 38 matching lines @@
   }
 }
 
 
 static bool IsValidJSON(const char* msg) {
   dart::JSONReader r(msg);
   return r.EndOfObject() != NULL;
 }
 
 
+void DebuggerConnectionHandler::SendMsg(dart::TextBuffer* msg) {
+  ASSERT(debugger_fd_ >= 0);
+  Socket::Write(debugger_fd_, msg->buf(), msg->length());
+  // TODO(hausner): Error checking. Probably just shut down the debugger
+  // session if we there is an error while writing.
+}
+
+
+void DebuggerConnectionHandler::QueueMsg(dart::TextBuffer* msg) {
+  queued_messages_.Printf("%s", msg->buf());
+}
+
+
+void DebuggerConnectionHandler::SendQueuedMsgs() {
+  if (queued_messages_.length() > 0) {
+    SendMsg(&queued_messages_);
+    queued_messages_.Clear();
+  }
+}
+
+
 void DebuggerConnectionHandler::SendError(int msg_id,
                                           const char* err_msg) {
   dart::TextBuffer msg(64);
   msg.Printf("{\"id\": %d, \"error\": \"Error: %s\"}", msg_id, err_msg);
-  Socket::Write(debugger_fd_, msg.buf(), msg.length());
-  // TODO(hausner): Error checking. Probably just shut down the debugger
-  // session if we there is an error while writing.
+  SendMsg(&msg);
 }
 
 
 void DebuggerConnectionHandler::HandleResumeCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   dart::TextBuffer msg(64);
   msg.Printf("{ \"id\": %d }", msg_id);
-  Socket::Write(debugger_fd_, msg.buf(), msg.length());
-  // TODO(hausner): Error checking. Probably just shut down the debugger
-  // session if we there is an error while writing.
+  SendMsg(&msg);
   request_resume_ = true;
 }
 
 
 void DebuggerConnectionHandler::HandleStepIntoCmd(const char* json_msg) {
   Dart_Handle res = Dart_SetStepInto();
   ASSERT_NOT_ERROR(res);
   HandleResumeCmd(json_msg);
 }
 
@@ skipping 35 matching lines @@
   msg.Printf("{ \"id\": %d, ", msg_id);
   msg.Printf("\"result\": { \"urls\": [");
   for (int i = 0; i < num_urls; i++) {
     Dart_Handle script_url = Dart_ListGetAt(urls, i);
     ASSERT(Dart_IsString(script_url));
     char const* chars;
     Dart_StringToCString(lib_url, &chars);
     msg.Printf("%s\"%s\"", (i == 0) ? "" : ", ", chars);
   }
   msg.Printf("] }}");
-  Socket::Write(debugger_fd_, msg.buf(), msg.length());
-  // TODO(hausner): Error checking. Probably just shut down the debugger
-  // session if we there is an error while writing.
+  SendMsg(&msg);
 }
 
 
 void DebuggerConnectionHandler::HandleGetLibraryURLsCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   dart::TextBuffer msg(64);
   msg.Printf("{ \"id\": %d, \"result\": { \"urls\": [", msg_id);
   Dart_Handle urls = Dart_GetLibraryURLs();
   ASSERT_NOT_ERROR(urls);
   intptr_t num_libs;
   Dart_ListLength(urls, &num_libs);
   for (int i = 0; i < num_libs; i++) {
     Dart_Handle lib_url = Dart_ListGetAt(urls, i);
     ASSERT(Dart_IsString(lib_url));
     char const* chars;
     Dart_StringToCString(lib_url, &chars);
     msg.Printf("%s\"%s\"", (i == 0) ? "" : ", ", chars);
   }
   msg.Printf("] }}");
-  Socket::Write(debugger_fd_, msg.buf(), msg.length());
-  // TODO(hausner): Error checking. Probably just shut down the debugger
-  // session if we there is an error while writing.
+  SendMsg(&msg);
+}
+
+
+static void FormatCallFrames(dart::TextBuffer* msg, Dart_StackTrace trace) {
+  intptr_t trace_len = 0;
+  Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
+  ASSERT_NOT_ERROR(res);
+  msg->Printf("\"callFrames\" : [ ");
+  for (int i = 0; i < trace_len; i++) {
+    Dart_ActivationFrame frame;
+    res = Dart_GetActivationFrame(trace, i, &frame);
+    ASSERT_NOT_ERROR(res);
+    Dart_Handle func_name;
+    Dart_Handle script_url;
+    intptr_t line_number = 0;
+    res = Dart_ActivationFrameInfo(
+        frame, &func_name, &script_url, &line_number);
+    ASSERT_NOT_ERROR(res);
+    ASSERT(Dart_IsString(func_name));
+    const char* func_name_chars;
+    Dart_StringToCString(func_name, &func_name_chars);
+    msg->Printf("%s { \"functionName\": \"%s\" , ",
+               i > 0 ? "," : "",
+               func_name_chars);
+    ASSERT(Dart_IsString(script_url));
+    const char* script_url_chars;
+    Dart_StringToCString(script_url, &script_url_chars);
+    msg->Printf("\"location\": { \"url\": \"%s\", \"lineNumber\": %d }}",
+               script_url_chars, line_number);
+  }
+  msg->Printf("]");
+}
+
+
+void DebuggerConnectionHandler::HandleGetStackTraceCmd(const char* json_msg) {
+  int msg_id = msgbuf_->MessageId();
+  Dart_StackTrace trace;
+  Dart_Handle res = Dart_GetStackTrace(&trace);
+  ASSERT_NOT_ERROR(res);
+  dart::TextBuffer msg(128);
+  msg.Printf("{ \"id\": %d, \"result\": {", msg_id);
+  FormatCallFrames(&msg, trace);
+  msg.Printf("}}");
+  SendMsg(&msg);
+}
+
+
+void DebuggerConnectionHandler::HandleSetBpCmd(const char* json_msg) {
+  int msg_id = msgbuf_->MessageId();
+  const char* params = msgbuf_->Params();
+  ASSERT(params != NULL);
+  dart::JSONReader pr(params);
+  pr.Seek("url");
+  ASSERT(pr.Type() == dart::JSONReader::kString);
+  char url_chars[128];
+  pr.GetValueChars(url_chars, sizeof(url_chars));
+  Dart_Handle url = Dart_NewString(url_chars);
+  ASSERT_NOT_ERROR(url);
+  pr.Seek("line");
+  ASSERT(pr.Type() == dart::JSONReader::kInteger);
+  intptr_t line_number = atoi(pr.ValueChars());
+  Dart_Handle bp_id = Dart_SetBreakpoint(url, line_number);
+  if (Dart_IsError(bp_id)) {
+    SendError(msg_id, Dart_GetError(bp_id));
+    return;
+  }
+  ASSERT(Dart_IsInteger(bp_id));
+  uint64_t bp_id_value;
+  Dart_Handle res = Dart_IntegerToUint64(bp_id, &bp_id_value);
+  ASSERT_NOT_ERROR(res);
+  dart::TextBuffer msg(64);
+  msg.Printf("{ \"id\": %d, \"result\": { \"breakpointId\": %d }}",
+             msg_id, bp_id_value);
+  SendMsg(&msg);
+}
+
+
+void DebuggerConnectionHandler::HandleUnknownMsg(const char* json_msg) {
+  int msg_id = msgbuf_->MessageId();
+  ASSERT(msg_id >= 0);
+  SendError(msg_id, "unknown debugger command");
 }
 
 
 void DebuggerConnectionHandler::HandleMessages() {
   static JSONDebuggerCommand debugger_commands[] = {
     { "resume", HandleResumeCmd },
     { "getLibraryURLs", HandleGetLibraryURLsCmd},
     { "getScriptURLs", HandleGetScriptURLsCmd },
+    { "getStackTrace", HandleGetStackTraceCmd },
+    { "setBreakpoint", HandleSetBpCmd },
     { "stepInto", HandleStepIntoCmd },
     { "stepOut", HandleStepOutCmd },
     { "stepOver", HandleStepOverCmd },
     { NULL, NULL }
   };
 
   for (;;) {
+    SendQueuedMsgs();
     while (!msgbuf_->IsValidMessage() && msgbuf_->Alive()) {
       msgbuf_->ReadData();
     }
     if (!msgbuf_->Alive()) {
       return;
     }
     dart::JSONReader r(msgbuf_->buf());
     bool found = r.Seek("command");
     if (r.Error()) {
       FATAL("Illegal JSON message received");
@@ skipping 12 matching lines @@
         msgbuf_->PopMessage();
         if (request_resume_) {
           return;
         }
         break;
       }
       i++;
     }
     if (!is_handled) {
       printf("unrecognized command received: '%s'\n", msgbuf_->buf());
+      HandleUnknownMsg(msgbuf_->buf());
       msgbuf_->PopMessage();
     }
   }
 }
 
 
 void DebuggerConnectionHandler::SendBreakpointEvent(Dart_Breakpoint bpt,
                                                     Dart_StackTrace trace) {
   dart::TextBuffer msg(128);
-  intptr_t trace_len = 0;
-  Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
-  ASSERT_NOT_ERROR(res);
-  msg.Printf("{ \"event\": \"paused\", \"params\": ");
-  msg.Printf("{ \"callFrames\" : [ ");
-  for (int i = 0; i < trace_len; i++) {
-    Dart_ActivationFrame frame;
-    res = Dart_GetActivationFrame(trace, i, &frame);
-    ASSERT_NOT_ERROR(res);
-    Dart_Handle func_name;
-    Dart_Handle script_url;
-    intptr_t line_number = 0;
-    res = Dart_ActivationFrameInfo(
-              frame, &func_name, &script_url, &line_number);
-    ASSERT_NOT_ERROR(res);
-    ASSERT(Dart_IsString(func_name));
-    const char* func_name_chars;
-    Dart_StringToCString(func_name, &func_name_chars);
-    msg.Printf("%s { \"functionName\": \"%s\" , ",
-              i > 0 ? "," : "",
-              func_name_chars);
-    ASSERT(Dart_IsString(script_url));
-    const char* script_url_chars;
-    Dart_StringToCString(script_url, &script_url_chars);
-    msg.Printf("\"location\": { \"url\": \"%s\", \"lineNumber\": %d }}",
-               script_url_chars, line_number);
-  }
-  msg.Printf("]}}");
+  msg.Printf("{ \"event\": \"paused\", \"params\": { ");
+  FormatCallFrames(&msg, trace);
+  msg.Printf("}}");
   Socket::Write(debugger_fd_, msg.buf(), msg.length());
   ASSERT(IsValidJSON(msg.buf()));
 }
 
 
 void DebuggerConnectionHandler::BreakpointHandler(Dart_Breakpoint bpt,
                                                   Dart_StackTrace trace) {
   {
     MonitorLocker ml(&is_connected_);
     while (!IsConnected()) {
       printf("Waiting for debugger connection...\n");
       dart::Monitor::WaitResult res = ml.Wait(dart::Monitor::kNoTimeout);
       ASSERT(res == dart::Monitor::kNotified);
     }
   }
   Dart_EnterScope();
+  SendQueuedMsgs();
   SendBreakpointEvent(bpt, trace);
   HandleMessages();
   if (!msgbuf_->Alive()) {
     CloseDbgConnection();
   }
   Dart_ExitScope();
 }
 
 
+void DebuggerConnectionHandler::BptResolvedHandler(intptr_t bp_id,
+                                                   Dart_Handle url,
+                                                   intptr_t line_number) {
+  Dart_EnterScope();
+  dart::TextBuffer msg(128);
+  msg.Printf("{ \"event\": \"breakpointResolved\", \"params\": {");
+  msg.Printf("\"breakpointId\": %d, ", bp_id);
+  char const* url_chars;
+  Dart_StringToCString(url, &url_chars);
+  msg.Printf("\"url\": \"%s\", ", url_chars);
+  msg.Printf("\"line\": %d }}", line_number);
+  QueueMsg(&msg);
+  Dart_ExitScope();
+}
+
+
 void DebuggerConnectionHandler::AcceptDbgConnection(int debugger_fd) {
   debugger_fd_ = debugger_fd;
   ASSERT(msgbuf_ == NULL);
   msgbuf_ = new MessageBuffer(debugger_fd_);
   {
     MonitorLocker ml(&is_connected_);
     ml.Notify();
   }
 }
 
+
 void DebuggerConnectionHandler::CloseDbgConnection() {
   if (debugger_fd_ >= 0) {
     // TODO(hausner): need a Socket::Close() function.
   }
   if (msgbuf_ != NULL) {
     delete msgbuf_;
     msgbuf_ = NULL;
   }
   // TODO(hausner): Need to tell the VM debugger object to remove all
   // breakpoints.
 }
 
+
 void DebuggerConnectionHandler::StartHandler(const char* address,
                                              int port_number) {
   if (handler_started_) {
     return;
   }
   ASSERT(listener_fd_ == -1);
   listener_fd_ = ServerSocket::CreateBindListen(address, port_number, 1);
 
   handler_started_ = true;
   DebuggerConnectionImpl::StartHandler(port_number);
   Dart_SetBreakpointHandler(BreakpointHandler);
+  Dart_SetBreakpointResolvedHandler(BptResolvedHandler);
 }
 
 
 DebuggerConnectionHandler::~DebuggerConnectionHandler() {
   CloseDbgConnection();
 }