Wire up the Inspector V8 Debugger

sky/framework/inspector/inspector.sky

 <import src="/mojo/public/sky/connection.sky" as="connection" />
 <import src="/mojo/public/sky/core.sky" as="core" />
 <import src="/mojo/public/sky/support.sky" as="support" />
 <import src="/sky/services/inspector/inspector.mojom.sky" as="inspector" />
 <import src="console-agent.sky" as="ConsoleAgent" />
 <import src="dom-agent.sky" as="DOMAgent" />
 <import src="page-agent.sky" as="PageAgent" />
 <import src="worker-agent.sky" as="WorkerAgent" />
 <import src="runtime-agent.sky" as="RuntimeAgent" />
 <import src="indexeddb-agent.sky" as="IndexedDBAgent" />
 <import src="css-agent.sky" as="CSSAgent" />
 <script>
 function InspectorBackend(frontend) {
   this.frontend = frontend;
   var domAgent = new DOMAgent(this);
   this.agents = {
     Console: new ConsoleAgent(),
     DOM: domAgent,
-    Page: new PageAgent(),
+    Page: new PageAgent(this),
     Worker: new WorkerAgent(),
     Runtime: new RuntimeAgent(this),
     CSS: new CSSAgent(domAgent),
     IndexedDB: new IndexedDBAgent(),
   };
   this.missingNames_ = {};
+  this.unansweredMessages_ = [];
 }
 
 InspectorBackend.prototype = Object.create(
     inspector.InspectorBackend.stubClass.prototype);
 
+InspectorBackend.prototype.ASYNC_RESPONSE = "ASYNC_RESPONSE";
+InspectorBackend.prototype.MESSAGE_TIMEOUT_MS = 30000;
+
 InspectorBackend.prototype.onConnect = function() {
 };
 
 InspectorBackend.prototype.onDisconnect = function() {
 };
 
 InspectorBackend.prototype.logMissing_ = function(name) {
   if (name in this.missingNames_)
     return;
   this.missingNames_[name] = true;
   console.log("InspectorBackend missing " + name);
 }
 
-InspectorBackend.prototype.dispatch_ = function(descriptor, params) {
+InspectorBackend.prototype.dispatch_ = function(descriptor, params, message_id) {
   var parsed = descriptor.split('.');
 
   var agentName = parsed[0];
   var methodName = parsed[1];
 
+  // Debugger is implemented in c++.
+  if (agentName == "Debugger")
+    return;
+
   if (!(agentName in this.agents)) {
     this.logMissing_(agentName);
     return {};
   }
 
   var agent = this.agents[agentName];
 
   if (!(methodName in agent)) {
-    this.logMissing_(agentName + "." + methodName);
+    this.logMissing_(descriptor);
     return {};
   }
 
   try {
-    return agent[methodName](params);
+    return agent[methodName](params, message_id);
   } catch(ex) {
     console.log(descriptor + ": " + ex);
   }
 };
 
 InspectorBackend.prototype.onMessage = function(data) {
   var message = JSON.parse(data);
-  var result = this.dispatch_(message.method, message.params);
+  var result = this.dispatch_(message.method, message.params, message.id);
+  this.unansweredMessages_.push(message.id);
+  // FIXME: This magic return value is kinda hacky.
+  if (result != this.ASYNC_RESPONSE)
+    this.sendResponse(message.id, result);
+  else {
+    window.setTimeout(function(message_id) {
+      if (this.unansweredMessages_.indexOf(message_id) == -1)
+        return;
+      console.log("Error, failed to reply to " + descriptor
+          + " message id " + message_id);
+    }, this.MESSAGE_TIMEOUT_MS, this, message.id);
+  }
+};
+
+InspectorBackend.prototype.sendResponse = function(message_id, result) {
+  var messageIndex = this.unansweredMessages_.indexOf(message_id);
+  if (messageIndex != -1)
+    this.unansweredMessages_.splice(messageIndex, 1);
+  else
+    console.log("Error, responding to unknown message id " + message_id);
   var response = {
-    id: message.id,
+    id: message_id,
   };
   if (typeof result !== "undefined")
     response.result = result;
   this.frontend.sendMessage(JSON.stringify(response));
-};
+}
 
 InspectorBackend.prototype.sendMessage = function(method, params) {
   var message = JSON.stringify({
     method: method,
     params: params,
   });
   this.frontend.sendMessage(message);
 };
 
 var frontendHandle = internals.connectToService(
     "mojo:sky_inspector_server", inspector.InspectorFrontend.name);
 window.frontendConnection = new connection.Connection(
     frontendHandle,
     InspectorBackend,
     inspector.InspectorFrontend.proxyClass);
 
 window.frontend = frontendConnection.remote;
 </script>