Add string encoding to wire protocol

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"
 
@@ skipping 36 matching lines @@
 
 class MessageBuffer {
  public:
   explicit MessageBuffer(int fd);
   ~MessageBuffer();
   void ReadData();
   bool IsValidMessage() const;
   void PopMessage();
   int MessageId() const;
   const char* Params() const;
   intptr_t GetIntParam(const char* name) const;

[srdjan, 2012/06/02 00:03:08]

Could you add add a comment that the caller must free the allocated char* .

[hausner, 2012/06/02 00:06:53]

I can. Done.

+  char* GetStringParam(const char* name) const;
   char* buf() const { return buf_; }
   bool Alive() const { return connection_is_alive_; }
 
  private:
   static const int kInitialBufferSize = 256;
   char* buf_;
   int buf_length_;
   int fd_;
   int data_length_;
   bool connection_is_alive_;
@@ skipping 58 matching lines @@
 
 intptr_t MessageBuffer::GetIntParam(const char* name) const {
   const char* params = Params();
   ASSERT(params != NULL);
   dart::JSONReader r(params);
   r.Seek(name);
   ASSERT(r.Type() == dart::JSONReader::kInteger);
   return strtol(r.ValueChars(), NULL, 10);
 }
 
+char* MessageBuffer::GetStringParam(const char* name) const {
+  const char* params = Params();
+  ASSERT(params != NULL);
+  dart::JSONReader pr(params);
+  pr.Seek(name);
+  if (pr.Type() != dart::JSONReader::kString) {
+    return NULL;
+  }
+  intptr_t buflen = pr.ValueLen() + 1;
+  char* param_chars = reinterpret_cast<char*>(malloc(buflen));
+  pr.GetValueChars(param_chars, buflen);
+  // TODO(hausner): Decode escape sequences.
+  return param_chars;
+}
 
 void MessageBuffer::ReadData() {
   ASSERT(data_length_ >= 0);
   ASSERT(data_length_ < buf_length_);
   int max_read = buf_length_ - data_length_ - 1;
   if (max_read == 0) {
     // TODO(hausner):
     // Buffer is full. What should we do if there is no valid message
     // in the buffer? This might be possible if the client sends a message
     // that's larger than the buffer, of if the client sends malformed
@@ skipping 73 matching lines @@
   Dart_Handle res = Dart_StringToCString(str, &chars);
   ASSERT(!Dart_IsError(res));
   return chars;
 }
 
 
 static int GetIntValue(Dart_Handle int_handle) {
   int64_t int64_val = -1;
   ASSERT(Dart_IsInteger(int_handle));
   Dart_Handle res = Dart_IntegerToInt64(int_handle, &int64_val);
-  ASSERT(!Dart_IsError(res));
+  ASSERT_NOT_ERROR(res);
   // TODO(hausner): Range check.
   return int64_val;
 }
 
 
 void DebuggerConnectionHandler::HandleResumeCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   dart::TextBuffer msg(64);
   msg.Printf("{ \"id\": %d }", msg_id);
   SendMsg(&msg);
@@ skipping 15 matching lines @@
 }
 
 
 void DebuggerConnectionHandler::HandleStepOverCmd(const char* json_msg) {
   Dart_Handle res = Dart_SetStepOver();
   ASSERT_NOT_ERROR(res);
   HandleResumeCmd(json_msg);
 }
 
 
+static void FormatEncodedString(dart::TextBuffer* buf, Dart_Handle str) {
+  ASSERT(Dart_IsString8(str));
+  intptr_t str_len = 0;
+  Dart_Handle res = Dart_StringLength(str, &str_len);
+  ASSERT_NOT_ERROR(res);
+  uint8_t* codepoints = reinterpret_cast<uint8_t*>(malloc(str_len));
+  ASSERT(codepoints != NULL);
+  intptr_t actual_len = str_len;
+  res = Dart_StringGet8(str, codepoints, &actual_len);
+  ASSERT(str_len == actual_len);
+  buf->Printf("\"");
+  buf->PrintJsonString8(codepoints, str_len);
+  buf->Printf("\"");
+  free(codepoints);
+}
+
+
+static void FormatErrorMsg(dart::TextBuffer* buf, Dart_Handle err) {
+  // TODO(hausner): Turn message into Dart string and
+  // properly encode the message.
+  ASSERT(Dart_IsError(err));
+  const char* msg = Dart_GetError(err);
+  buf->Printf("\"%s\"", msg);
+}
+
+
 void DebuggerConnectionHandler::HandleGetScriptURLsCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   dart::TextBuffer msg(64);
   intptr_t lib_id = msgbuf_->GetIntParam("libraryId");
   Dart_Handle lib_url = Dart_GetLibraryURL(lib_id);
   ASSERT_NOT_ERROR(lib_url);
   Dart_Handle urls = Dart_GetScriptURLs(lib_url);
   if (Dart_IsError(urls)) {
     SendError(msg_id, Dart_GetError(urls));
     return;
   }
   ASSERT(Dart_IsList(urls));
   intptr_t num_urls = 0;
   Dart_ListLength(urls, &num_urls);
   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);
-    msg.Printf("%s\"%s\"", (i == 0) ? "" : ", ", GetStringChars(script_url));
+    if (i > 0) {
+      msg.Printf(",");
+    }
+    FormatEncodedString(&msg, script_url);
   }
-  msg.Printf("] }}");
+  msg.Printf("]}}");
+  SendMsg(&msg);
+}
+
+
+void DebuggerConnectionHandler::HandleGetSourceCmd(const char* json_msg) {
+  int msg_id = msgbuf_->MessageId();
+  dart::TextBuffer msg(64);
+  intptr_t lib_id = msgbuf_->GetIntParam("libraryId");
+  char* url_chars = msgbuf_->GetStringParam("url");
+  ASSERT(url_chars != NULL);
+  Dart_Handle url = Dart_NewString(url_chars);
+  ASSERT_NOT_ERROR(url);
+  free(url_chars);
+  url_chars = NULL;
+  Dart_Handle source = Dart_ScriptGetSource(lib_id, url);
+  if (Dart_IsError(source)) {
+    SendError(msg_id, Dart_GetError(source));
+    return;
+  }
+  msg.Printf("{ \"id\": %d, ", msg_id);
+  msg.Printf("\"result\": { \"text\": ");
+  FormatEncodedString(&msg, source);
+  msg.Printf("}}");
   SendMsg(&msg);
 }
 
 
 void DebuggerConnectionHandler::HandleGetLibrariesCmd(const char* json_msg) {
   int msg_id = msgbuf_->MessageId();
   dart::TextBuffer msg(64);
   msg.Printf("{ \"id\": %d, \"result\": { \"libraries\": [", msg_id);
   Dart_Handle lib_ids = Dart_GetLibraryIds();
   ASSERT_NOT_ERROR(lib_ids);
   intptr_t num_libs;
   Dart_Handle res = Dart_ListLength(lib_ids, &num_libs);
   ASSERT_NOT_ERROR(res);
   for (int i = 0; i < num_libs; i++) {
     Dart_Handle lib_id_handle = Dart_ListGetAt(lib_ids, i);
     ASSERT(Dart_IsInteger(lib_id_handle));
     int lib_id = GetIntValue(lib_id_handle);
     Dart_Handle lib_url = Dart_GetLibraryURL(lib_id);
     ASSERT_NOT_ERROR(lib_url);
-    ASSERT(!Dart_IsNull(lib_url));
     ASSERT(Dart_IsString(lib_url));
-    char const* chars = NULL;
-    Dart_StringToCString(lib_url, &chars);
-    msg.Printf("%s{\"id\":%d,\"url\":\"%s\"}",
-               (i == 0) ? "" : ", ", lib_id, chars);
+    msg.Printf("%s{\"id\":%d,\"url\":", (i == 0) ? "" : ", ", lib_id);
+    FormatEncodedString(&msg, lib_url);
+    msg.Printf("}");
   }
   msg.Printf("]}}");
   SendMsg(&msg);
 }
 
 
 static void FormatField(dart::TextBuffer* buf,
                         Dart_Handle object_name,
                         Dart_Handle object) {
   ASSERT(Dart_IsString(object_name));
   buf->Printf("{\"name\":\"%s\",", GetStringChars(object_name));
   intptr_t obj_id = Dart_CacheObject(object);
   ASSERT(obj_id >= 0);
   buf->Printf("\"value\":{\"objectId\":%d,", obj_id);
   const char* kind = "object";
   if (Dart_IsInteger(object)) {
     kind = "integer";
   } else if (Dart_IsString(object)) {
     kind = "string";
   } else if (Dart_IsBoolean(object)) {
     kind = "boolean";
   }
   buf->Printf("\"kind\":\"%s\",", kind);
-  Dart_Handle text = Dart_ToString(object);
-  buf->Printf("\"text\":\"%s\"}}", GetStringChars(text));
+  buf->Printf("\"text\":");
+  Dart_Handle text;
+  if (Dart_IsNull(object)) {
+    text = Dart_Null();
+  } else {
+    text = Dart_ToString(object);
+  }
+  if (Dart_IsNull(text)) {
+    buf->Printf("null");
+  } else if (Dart_IsError(text)) {
+    FormatErrorMsg(buf, text);
+  } else {
+    FormatEncodedString(buf, text);
+  }
+  buf->Printf("}}");
 }
 
 
 static void FormatFieldList(dart::TextBuffer* buf,
                             Dart_Handle obj_list) {
   ASSERT(Dart_IsList(obj_list));
   intptr_t list_length = 0;
   Dart_Handle res = Dart_ListLength(obj_list, &list_length);
   ASSERT_NOT_ERROR(res);
   ASSERT(list_length % 2 == 0);
@@ skipping 31 matching lines @@
   FormatFieldList(buf, static_fields);
   buf->Printf("}");
   return NULL;
 }
 
 
 static const char* FormatLibraryProps(dart::TextBuffer* buf,
                                       intptr_t lib_id) {
   Dart_Handle url = Dart_GetLibraryURL(lib_id);
   RETURN_IF_ERROR(url);
-  buf->Printf("{\"url\":\"%s\",", GetStringChars(url));
+  buf->Printf("{\"url\":");
+  FormatEncodedString(buf, url);
 
   // Imports and prefixes.
   Dart_Handle import_list = Dart_GetLibraryImports(lib_id);
   RETURN_IF_ERROR(import_list);
   ASSERT(Dart_IsList(import_list));
   intptr_t list_length = 0;
   Dart_Handle res = Dart_ListLength(import_list, &list_length);
   RETURN_IF_ERROR(res);
-  buf->Printf("\"imports\":[");
+  buf->Printf(",\"imports\":[");
   for (int i = 0; i + 1 < list_length; i += 2) {
     Dart_Handle lib_id = Dart_ListGetAt(import_list, i + 1);
     ASSERT_NOT_ERROR(lib_id);
     buf->Printf("%s{\"libraryId\":%d,",
                 (i > 0) ? ",": "",
                 GetIntValue(lib_id));
 
     Dart_Handle name = Dart_ListGetAt(import_list, i);
     ASSERT_NOT_ERROR(name);
     buf->Printf("\"prefix\":\"%s\"}",
@@ skipping 36 matching lines @@
   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);
+    msg->Printf("%s{\"functionName\":", (i > 0) ? "," : "");
+    FormatEncodedString(msg, func_name);
+
     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(",\"location\": { \"url\":");
+    FormatEncodedString(msg, script_url);
+    msg->Printf(",\"lineNumber\":%d},", line_number);
+
     Dart_Handle locals = Dart_GetLocalVariables(frame);
     ASSERT_NOT_ERROR(locals);
     msg->Printf("\"locals\":");
     FormatFieldList(msg, locals);
     msg->Printf("}");
   }
   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));
+  char* url_chars = msgbuf_->GetStringParam("url");
+  ASSERT(url_chars != NULL);
   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());
+  free(url_chars);
+  url_chars = NULL;
+  intptr_t line_number = msgbuf_->GetIntParam("line");
   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);
@@ skipping 75 matching lines @@
 
 
 void DebuggerConnectionHandler::HandleMessages() {
   static JSONDebuggerCommand debugger_commands[] = {
     { "resume", HandleResumeCmd },
     { "getLibraries", HandleGetLibrariesCmd },
     { "getClassProperties", HandleGetClassPropsCmd },
     { "getLibraryProperties", HandleGetLibPropsCmd },
     { "getObjectProperties", HandleGetObjPropsCmd },
     { "getScriptURLs", HandleGetScriptURLsCmd },
+    { "getScriptSource", HandleGetSourceCmd },
     { "getStackTrace", HandleGetStackTraceCmd },
     { "setBreakpoint", HandleSetBpCmd },
     { "removeBreakpoint", HandleRemBpCmd },
     { "stepInto", HandleStepIntoCmd },
     { "stepOut", HandleStepOutCmd },
     { "stepOver", HandleStepOverCmd },
     { NULL, NULL }
   };
 
   for (;;) {
@@ skipping 68 matching lines @@
   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);
+  msg.Printf("\"breakpointId\": %d, \"url\":", bp_id);
+  FormatEncodedString(&msg, url);
+  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_);
   {
@@ skipping 27 matching lines @@
   handler_started_ = true;
   DebuggerConnectionImpl::StartHandler(port_number);
   Dart_SetBreakpointHandler(BreakpointHandler);
   Dart_SetBreakpointResolvedHandler(BptResolvedHandler);
 }
 
 
 DebuggerConnectionHandler::~DebuggerConnectionHandler() {
   CloseDbgConnection();
 }