Change the D8 JavaScript debugger to fully use the JSON protocol....

src/debug-delay.js

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 853 matching lines @@
   return this.exec_state_.frame(0).sourceColumn();
 };
 
 
 ExceptionEvent.prototype.sourceLineText = function() {
   return this.exec_state_.frame(0).sourceLineText();
 };
 
 
 ExceptionEvent.prototype.toJSONProtocol = function() {
-  var o = { seq: next_response_seq++,
-            type: "event",
-            event: "exception",
-            body: { uncaught: this.uncaught_,
-                    exception: MakeMirror(this.exception_),
-                    sourceLine: this.sourceLine(),
-                    sourceColumn: this.sourceColumn(),
-                    sourceLineText: this.sourceLineText(),
-                  }
-          }
+  var o = new ProtocolMessage();
+  o.event = "exception";
+  o.body = { uncaught: this.uncaught_,
+             exception: MakeMirror(this.exception_)
+           }
+           
+  // Exceptions might happen whithout any JavaScript frames.
+  if (this.exec_state_.frameCount() > 0) {
+    o.body.sourceLine = this.sourceLine();
+    o.body.sourceColumn = this.sourceColumn();
+    o.body.sourceLineText = this.sourceLineText();
 
-  // Add script information to the event if available.
-  var script = this.func().script();
-  if (script) {
-    o.body.script = { name: script.name(),
-                      lineOffset: script.lineOffset(),
-                      columnOffset: script.columnOffset(),
-                      lineCount: script.lineCount()
-                    };
+    // Add script information to the event if available.
+    var script = this.func().script();
+    if (script) {
+      o.body.script = { name: script.name(),
+                        lineOffset: script.lineOffset(),
+                        columnOffset: script.columnOffset(),
+                        lineCount: script.lineCount()
+                      };
+    }
+  } else {
+    o.body.sourceLine = -1;
   }
 
-  return SimpleObjectToJSON_(o);
+  return o.toJSONProtocol();
 };
 
 
 function MakeCompileEvent(exec_state, script, before) {
   return new CompileEvent(exec_state, script, before);
 }
 
 
 function CompileEvent(exec_state, script, before) {
   this.exec_state_ = exec_state;
@@ skipping 14 matching lines @@
     return Debug.DebugEvent.AfterCompile;
   }
 };
 
 
 CompileEvent.prototype.script = function() {
   return this.script_;
 };
 
 
+CompileEvent.prototype.toJSONProtocol = function() {
+  var o = new ProtocolMessage();
+  if (this.before_) {
+    o.event = "beforeCompile";
+  } else {
+    o.event = "afterCompile";
+  }
+  o.body = {};
+  o.body.script = { name: this.script_.name(),
+                    lineOffset: this.script_.lineOffset(),
+                    columnOffset: this.script_.columnOffset(),
+                    lineCount: this.script_.lineCount(),
+                    source: this.script_.source()
+                   };
+
+  return o.toJSONProtocol();
+}
+
+
 function MakeNewFunctionEvent(func) {
   return new NewFunctionEvent(func);
 }
 
 
 function NewFunctionEvent(func) {
   this.func = func;
 }
 
 
@@ skipping 16 matching lines @@
   this.exec_state_ = exec_state;
   this.running_ = false;
 };
 
 
 DebugCommandProcessor.prototype.processDebugRequest = function (request) {
   return this.processDebugJSONRequest(request);
 }
 
 
-function ResponsePacket(request) {
-  // Build the initial response from the request.
+function ProtocolMessage(request) {
+  // Update sequence number.
   this.seq = next_response_seq++;
-  this.type = 'response';
-  if (request) this.request_seq = request.seq;
-  if (request) this.command = request.command;
+  
+  if (request) {
+    // If message is based on a request this is a response. Fill the initial
+    // response from the request.
+    this.type = 'response';
+    this.request_seq = request.seq;
+    this.command = request.command;
+  } else {
+    // If message is not based on a request it is a dabugger generated event.
+    this.type = 'event';
+  }
   this.success = true;
   this.running = false;
 }
 
 
-ResponsePacket.prototype.failed = function(message) {
+ProtocolMessage.prototype.failed = function(message) {
   this.success = false;
   this.message = message;
 }
 
 
-ResponsePacket.prototype.toJSONProtocol = function() {
+ProtocolMessage.prototype.toJSONProtocol = function() {
   // Encode the protocol header.
   var json = '{';
   json += '"seq":' + this.seq;
   if (this.request_seq) {
     json += ',"request_seq":' + this.request_seq;
   }
   json += ',"type":"' + this.type + '"';
+  if (this.event) {
+    json += ',"event":' + StringToJSON_(this.event);
+  }
   if (this.command) {
     json += ',"command":' + StringToJSON_(this.command);
   }
   if (this.success) {
     json += ',"success":' + this.success;
   } else {
     json += ',"success":false';
   }
   if (this.body) {
     json += ',"body":';
@@ skipping 25 matching lines @@
     json += ',"running":true';
   } else {
     json += ',"running":false';
   }
   json += '}';
   return json;
 }
 
 
 DebugCommandProcessor.prototype.createResponse = function(request) {
-  return new ResponsePacket(request);
+  return new ProtocolMessage(request);
 };
 
 
 DebugCommandProcessor.prototype.processDebugJSONRequest = function(json_request) {
   var request;  // Current request.
   var response;  // Generated response.
   try {
     try {
       // Convert the JSON string to an object.
       request = %CompileString('(' + json_request + ')', 0)();
@@ skipping 598 matching lines @@
   var content = [];
   for (var key in object) {
     // Only consider string keys.
     if (typeof key == 'string') {
       var property_value = object[key];
 
       // Format the value based on its type.
       var property_value_json;
       switch (typeof property_value) {
         case 'object':
-          if (typeof property_value.toJSONProtocol == 'function') {
+          if (property_value instanceof Mirror) {
+            property_value_json = mirror_serializer.serializeValue(property_value);
+          } else if (typeof property_value.toJSONProtocol == 'function') {
             property_value_json = property_value.toJSONProtocol(true)
           } else if (IS_ARRAY(property_value)){
             property_value_json = SimpleArrayToJSON_(property_value, mirror_serializer);
           } else {
             property_value_json = SimpleObjectToJSON_(property_value, mirror_serializer);
           }
           break;
 
         case 'boolean':
           property_value_json = BooleanToJSON_(property_value);
@@ skipping 48 matching lines @@
       json += NumberToJSON_(elem);
     } else if (IS_STRING(elem)) {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
 }