Cleanup JS() expressions. New Constructor for JsObject that preserves the correct prototype. Type c…

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;
   }
 
-  // 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;
+  var _dartRefPropertyName = "_$dart_ref";
+
+  // attempts to add an unenumerable property to o. If that is not allowed
+  // it silently fails.
+  function _defineProperty(o, name, value) {
+    if (Object.isExtensible(o)) {
+      try {
+        Object.defineProperty(o, name, { 'value': value });
+      } catch (e) {
+        // object is native and lies about being extensible
+        // see https://bugzilla.mozilla.org/show_bug.cgi?id=775185
       }
     }
-    var ref = this.name + '-' + this._nextId++;
-    this.map[ref] = obj;
-    return ref;
+  }
+
+  // Adds an object to the table and return an ID for serialization.
+  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;
+        _defineProperty(obj, _dartRefPropertyName, ref);
+      }
+      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);
 
-    // Until 10 args, the 'new' operator is used. With more arguments we use a
-    // generic way that may not work, particularly when the constructor does not
-    // have an "apply" method.
-    var ret = null;
-    if (args.length === 0) {
-      ret = new constructor();
-    } else if (args.length === 1) {
-      ret = new constructor(args[0]);
-    } else if (args.length === 2) {
-      ret = new constructor(args[0], args[1]);
-    } else if (args.length === 3) {
-      ret = new constructor(args[0], args[1], args[2]);
-    } else if (args.length === 4) {
-      ret = new constructor(args[0], args[1], args[2], args[3]);
-    } else if (args.length === 5) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4]);
-    } else if (args.length === 6) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4],
-                            args[5]);
-    } else if (args.length === 7) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4],
-                            args[5], args[6]);
-    } else if (args.length === 8) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4],
-                            args[5], args[6], args[7]);
-    } else if (args.length === 9) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4],
-                            args[5], args[6], args[7], args[8]);
-    } else if (args.length === 10) {
-      ret = new constructor(args[0], args[1], args[2], args[3], args[4],
-                            args[5], args[6], args[7], args[8], args[9]);
-    } else {
-      // Dummy Type with correct constructor.
-      var Type = function(){};
-      Type.prototype = constructor.prototype;
-
-      // Create a new instance
-      var instance = new Type();
-
-      // Call the original constructor.
-      ret = constructor.apply(instance, args);
-      ret = Object(ret) === ret ? ret : instance;
-    }
-    return serialize(ret);
+    // The following code solves the problem of invoking a JavaScript
+    // constructor with an unknown number arguments.
+    // First bind the constructor to the argument list using bind.apply().
+    // The first argument to bind() is the binding of 'this', make it 'null'
+    // After that, use the JavaScript 'new' operator which overrides any binding
+    // of 'this' with the new instance.
+    args[0] = null;
+    var factoryFunction = constructor.bind.apply(constructor, args);
+    return serialize(new factoryFunction());
   }
 
   // Remote handler to return the top-level JavaScript context.
   function context(data) {
     return serialize(globalContext);
   }
 
   // Return true if a JavaScript proxy is instance of a given type (instanceof).
   function proxyInstanceof(args) {
     var obj = deserialize(args[0]);
@@ skipping 37 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);
 })();