Maintain referential integrity of proxy instances in dart:js

pkg/browser/lib/interop.js

 // Copyright (c) 2013, 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.
 
 // ---------------------------------------------------------------------------
 // Support for JS interoperability
 // ---------------------------------------------------------------------------
 function SendPortSync() {
 }
 
 function ReceivePortSync() {
   this.id = ReceivePortSync.id++;
   ReceivePortSync.map[this.id] = this;
 }
 
 // Type for remote proxies to Dart objects with dart2js.
-function DartProxy(o) {
+function DartObject(o) {
   this.o = o;
 }
 
 (function() {
   // Serialize the following types as follows:
   //  - primitives / null: unchanged
   //  - lists: [ 'list', internal id, list of recursively serialized elements ]
   //  - maps: [ 'map', internal id, map of keys and recursively serialized values ]
   //  - send ports: [ 'sendport', type, isolate id, port id ]
   //
@@ skipping 215 matching lines @@
     this.port = new ReceivePortSync();
     this.sendPort = this.port.toSendPort();
   }
 
   // Number of valid IDs.  This is the number of objects (global and local)
   // kept alive by this table.
   ProxiedObjectTable.prototype.count = function () {
     return Object.keys(this.map).length;
   }
 
+  var _dartRefPropertyName = "_$dart_ref";
+
   // Adds an object to the table and return an ID for serialization.
-  ProxiedObjectTable.prototype.add = function (obj) {
-    for (var ref in this.map) {
-      var o = this.map[ref];
-      if (o === obj) {
-        return ref;
+  ProxiedObjectTable.prototype.add = function (obj, id) {
+    if (id != null) {
+      this.map[id] = obj;
+      return id;
+    } else {
+      var ref = obj[_dartRefPropertyName];
+      if (ref == null) {
+        ref = this.name + '-' + this._nextId++;
+        this.map[ref] = obj;
+        Object.defineProperty(obj, _dartRefPropertyName, { value: ref });

[ahe, 2013/10/11 12:54:40]

Why are you using Object.defineProperty?

[alexandre.ardhuin, 2013/10/11 13:52:53]

To avoid that this property shows up during property enumeration on obj.

       }
+      return ref;
     }
-    var ref = this.name + '-' + this._nextId++;
-    this.map[ref] = obj;
-    return ref;
   }
 
   // Gets the object or function corresponding to this ID.
+  ProxiedObjectTable.prototype.contains = function (id) {
+    return this.map.hasOwnProperty(id);
+  }
+
+  // Gets the object or function corresponding to this ID.
   ProxiedObjectTable.prototype.get = function (id) {
     if (!this.map.hasOwnProperty(id)) {
       throw 'Proxy ' + id + ' has been invalidated.'
     }
     return this.map[id];
   }
 
   ProxiedObjectTable.prototype._initialize = function () {
     // Configure this table's port to forward methods, getters, and setters
     // from the remote proxy to the local object.
@@ skipping 44 matching lines @@
         return [ 'throws', e.toString() ];
       }
     });
   }
 
   // Singleton for local proxied objects.
   var proxiedObjectTable = new ProxiedObjectTable();
   proxiedObjectTable._initialize()
 
   // Type for remote proxies to Dart objects.
-  function DartProxy(id, sendPort) {
+  function DartObject(id, sendPort) {
     this.id = id;
     this.port = sendPort;
   }
 
   // Serializes JS types to SendPortSync format:
   // - primitives -> primitives
   // - sendport -> sendport
   // - Function -> [ 'funcref', function-id, sendport ]
   // - Object -> [ 'objref', object-id, sendport ]
   function serialize(message) {
@@ skipping 12 matching lines @@
         // Remote function proxy.
         var remoteId = message._dart_id;
         var remoteSendPort = message._dart_port;
         return [ 'funcref', remoteId, remoteSendPort ];
       } else {
         // Local function proxy.
         return [ 'funcref',
                  proxiedObjectTable.add(message),
                  proxiedObjectTable.sendPort ];
       }
-    } else if (message instanceof DartProxy) {
+    } else if (message instanceof DartObject) {
       // Remote object proxy.
       return [ 'objref', message.id, message.port ];
     } else {
       // Local object proxy.
       return [ 'objref',
                proxiedObjectTable.add(message),
                proxiedObjectTable.sendPort ];
     }
   }
 
@@ skipping 20 matching lines @@
   // Create a local function that forwards to the remote function.
   function deserializeFunction(message) {
     var id = message[1];
     var port = message[2];
     // TODO(vsm): Add a more robust check for a local SendPortSync.
     if ("receivePort" in port) {
       // Local function.
       return proxiedObjectTable.get(id);
     } else {
       // Remote function.  Forward to its port.
+      if (proxiedObjectTable.contains(id)) {
+        return proxiedObjectTable.get(id);
+      }
       var f = function () {
         var args = Array.prototype.slice.apply(arguments);
         args.splice(0, 0, this);
         args = args.map(serialize);
         var result = port.callSync([id, '#call', args]);
         if (result[0] == 'throws') throw deserialize(result[1]);
         return deserialize(result[1]);
       };
       // Cache the remote id and port.
       f._dart_id = id;
       f._dart_port = port;
+      proxiedObjectTable.add(f, id);
       return f;
     }
   }
 
-  // Creates a DartProxy to forwards to the remote object.
+  // Creates a DartObject to forwards to the remote object.
   function deserializeObject(message) {
     var id = message[1];
     var port = message[2];
     // TODO(vsm): Add a more robust check for a local SendPortSync.
     if ("receivePort" in port) {
       // Local object.
       return proxiedObjectTable.get(id);
     } else {
       // Remote object.
-      return new DartProxy(id, port);
+      if (proxiedObjectTable.contains(id)) {
+        return proxiedObjectTable.get(id);
+      }
+      proxy = new DartObject(id, port);
+      proxiedObjectTable.add(proxy, id);
+      return proxy;
     }
   }
 
   // Remote handler to construct a new JavaScript object given its
   // serialized constructor and arguments.
   function construct(args) {
     args = args.map(deserialize);
     var constructor = args[0];
     args = Array.prototype.slice.call(args, 1);
 
@@ skipping 91 matching lines @@
     port.receive(f);
     window.registerPort(name, port.toSendPort());
   }
 
   makeGlobalPort('dart-js-context', context);
   makeGlobalPort('dart-js-create', construct);
   makeGlobalPort('dart-js-instanceof', proxyInstanceof);
   makeGlobalPort('dart-js-delete-property', proxyDeleteProperty);
   makeGlobalPort('dart-js-convert', proxyConvert);
 })();