Support proxying of objects between JS and Dart.

client/dart.js

 // 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.
 
 // Bootstrap support for Dart scripts on the page as this script.
 if (navigator.webkitStartDart) {
   if (!navigator.webkitStartDart()) {
     document.body.innerHTML = 'This build has expired.  Please download a new Dartium at http://www.dartlang.org/dartium/index.html';
   }
 } else {
@@ skipping 28 matching lines @@
 // ---------------------------------------------------------------------------
 function SendPortSync() {
 }
 
 function ReceivePortSync() {
   this.id = ReceivePortSync.id++;
   ReceivePortSync.map[this.id] = this;
 }
 
 (function() {
-  // Track proxied functions.
-  // TODO: Fix leaks, particularly in dart2js case.
-  var functionRefMap = {};
+  function RefTable(name) {
+    // TODO(vsm): Fix leaks, particularly in dart2js case.
+    this.name = name;
+    this.map = {};
+    this.id = 0;
+    this.initialized = false;
+  }
+  
+  RefTable.prototype.nextId = function () { return this.id++; }
 
-  var nextFunctionRefId = 0;
-
-  function functionRefDispatch(message) {
-    var id = message[0];
-    var args = message[1];
-    var f = functionRefMap[id];
-    // TODO: Should we capture this automatically?
-    return f.apply(null, args);
-  }
-
-  var functionRefPort = null;
-
-  function makeFunctionRef(f) {
-    if (functionRefPort == null) {
-      var port = new ReceivePortSync();
-      port.receive(functionRefDispatch);
-      functionRefPort = port.toSendPort();
-    }
-    var ref = 'func-ref-' + (nextFunctionRefId++);
-    functionRefMap[ref] = f;
+  RefTable.prototype.makeRef = function (obj) {
+    this.initializeOnce();
+    // TODO(vsm): Cache refs for each obj.
+    var ref = this.name + '-' + this.nextId();
+    this.map[ref] = obj;
     return ref;
   }
 
+  RefTable.prototype.initializeOnce = function () {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    this.initialized = true;
+  }
+
+  // Overridable initialization on first use hook.
+  RefTable.prototype.initialize = function () {}
+
+  RefTable.prototype.get = function (ref) {
+    return this.map[ref];
+  }
+
+  function FunctionRefTable() {}
+
+  FunctionRefTable.prototype = new RefTable('func-ref');
+
+  FunctionRefTable.prototype.initialize = function () {
+    var receivePort = new ReceivePortSync();
+    map = this.map;
+    receivePort.receive(function (message) {
+      var id = message[0];
+      var args = message[1];
+      var f = map[id];
+      // TODO(vsm): Should we capture this automatically?
+      return f.apply(null, args);    
+    });
+    this.port = receivePort.toSendPort();
+  }
+
+  var functionRefTable = new FunctionRefTable();
+
+  function JSRefTable() {}
+
+  JSRefTable.prototype = new RefTable('js-ref');
+
+  var jsRefTable = new JSRefTable();
+
+  function DartProxy(id) {
+    // TODO(vsm): Set isolate id.
+    this.id = id;
+  }
+
   function serialize(message) {
     var visited = [];
     function checkedSerialization(obj, serializer) {
       // Implementation detail: for now use linear search.
       // Another option is expando, but it may prohibit
       // VM optimizations (like putting object into slow mode
       // on property deletion.)
       var id = visited.indexOf(obj);
       if (id != -1) return [ 'ref', id ];
       var id = visited.length;
@@ skipping 14 matching lines @@
           for (var i = 0; i < message.length; i++) {
             values[i] = doSerialize(message[i]);
           }
           return [ 'list', id, values ];
         });
       } else if (message instanceof LocalSendPortSync) {
         return [ 'sendport', 'nativejs', message.receivePort.id ];
       } else if (message instanceof DartSendPortSync) {
         return [ 'sendport', 'dart', message.isolateId, message.portId ];
       } else if (message instanceof Function) {
-        return [ 'funcref', makeFunctionRef(message),
-                 doSerialize(functionRefPort) ];
+        return [ 'funcref', functionRefTable.makeRef(message),
+                 doSerialize(functionRefTable.port) ];
+      } else if (message instanceof DartProxy) {
+        return [ 'objref', 'dart', message.id ];
+      } else if (message.__proto__ != {}.__proto__) {
+        // TODO(vsm): Is the above portable and what we want?
+        // Proxy non-map Objects.
+        return [ 'objref', 'nativejs', jsRefTable.makeRef(message) ];
       } else {
         return checkedSerialization(message, function(id) {
           var keys = Object.getOwnPropertyNames(message);
           var values = new Array(keys.length);
           for (var i = 0; i < keys.length; i++) {
             values[i] = doSerialize(message[keys[i]]);
           }
           return [ 'map', id, keys, values ];
         });
       }
     }
     return doSerialize(message);
   }
 
   function deserialize(message) {
     return deserializeHelper(message);
   }
 
-  function deserializeHelper(x) {
-    if (x == null ||
-        typeof(x) == 'string' ||
-        typeof(x) == 'number' ||
-        typeof(x) == 'boolean') {
-      return x;
+  function deserializeHelper(message) {
+    if (message == null ||
+        typeof(message) == 'string' ||
+        typeof(message) == 'number' ||
+        typeof(message) == 'boolean') {
+      return message;
     }
-    switch (x[0]) {
-      case 'map': return deserializeMap(x);
-      case 'sendport': return deserializeSendPort(x);
-      case 'list': return deserializeList(x);
-      case 'funcref': return deserializeFunction(x);
+    switch (message[0]) {
+      case 'map': return deserializeMap(message);
+      case 'sendport': return deserializeSendPort(message);
+      case 'list': return deserializeList(message);
+      case 'funcref': return deserializeFunction(message);
+      case 'objref': return deserializeProxy(message);
       default: throw 'unimplemented';
     }
   }
 
-  function deserializeMap(x) {
+  function deserializeMap(message) {
     var result = { };
-    var id = x[1];
-    var keys = x[2];
-    var values = x[3];
+    var id = message[1];
+    var keys = message[2];
+    var values = message[3];
     for (var i = 0, length = keys.length; i < length; i++) {
       var key = deserializeHelper(keys[i]);
       var value = deserializeHelper(values[i]);
       result[key] = value;
     }
     return result;
   }
 
-  function deserializeSendPort(x) {
-    var tag = x[1];
+  function deserializeSendPort(message) {
+    var tag = message[1];
     switch (tag) {
       case 'nativejs':
-        var id = x[2];
+        var id = message[2];
         return new LocalSendPortSync(ReceivePortSync.map[id]);
       case 'dart':
-        var isolateId = x[2];
-        var portId = x[3];
+        var isolateId = message[2];
+        var portId = message[3];
         return new DartSendPortSync(isolateId, portId);
       default:
         throw 'Illegal SendPortSync type: $tag';
     }
   }
 
-  function deserializeList(x) {
-    var values = x[2];
+  function deserializeList(message) {
+    var values = message[2];
     var length = values.length;
     var result = new Array(length);
     for (var i = 0; i < length; i++) {
       result[i] = deserializeHelper(values[i]);
     }
     return result;
   }
 
-  function deserializeFunction(x) {
-    var ref = x[1];
-    var sendPort = deserializeSendPort(x[2]);
+  function deserializeFunction(message) {
+    var ref = message[1];
+    var sendPort = deserializeSendPort(message[2]);
     // Number of arguments is not used as of now
     // we cannot find it out for Dart function in pure Dart.
     return _makeFunctionFromRef(ref, sendPort);
   }
 
+  function deserializeProxy(message) {
+    var tag = message[1];
+    if (tag == 'nativejs') {
+      var id = message[2];
+      return jsRefTable.map[id];
+    } else if (tag == 'dart') {
+      var id = message[2];
+      return new DartProxy(id);
+    }
+    throw 'Illegal proxy object: ' + message;
+  }
+
   window.registerPort = function(name, port) {
     var stringified = JSON.stringify(serialize(port));
     window.localStorage['dart-port:' + name] = stringified;
   };
 
   window.lookupPort = function(name) {
     var stringified = window.localStorage['dart-port:' + name];
     return deserialize(JSON.parse(stringified));
   };
 
@@ skipping 65 matching lines @@
     var listener = function (e) {
       result = JSON.parse(e.data);
     };
     window.addEventListener(source, listener, false);
     dispatchEvent(target, [source, serialized]);
     window.removeEventListener(source, listener, false);
     return deserialize(result);
   }
 
   // Leaking implementation.
-  // TODO: provide proper, backend-specific implementation.
+  // TODO(vsm): provide proper, backend-specific implementation.
   function _makeFunctionFromRef(ref, sendPort) {
     return function() {
       return sendPort.callSync([ref, Array.prototype.slice.call(arguments)]);
     }
   }
 })();