[js-interop] Fix function binding and avoid noSuchMethod when using map notation

lib/dart_interop.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.
 
 // THIS FILE IS AUTO GENERATED.  PLEASE DO NOT EDIT.
 
 // TODO(vsm): Move this file once we determine where assets should go.  See
 // http://dartbug.com/6101.
 
 (function() {
   // Proxy support for js.dart.
 
   var globalContext = window;
 
+  // Support for binding the receiver (this) in proxied functions.
+  function bindIfFunction(f, _this) {
+    if (typeof(f) != "function") {
+      return f;
+    } else {
+      return new BoundFunction(_this, f);
+    }
+  }
+
+  function unbind(obj) {
+    if (obj instanceof BoundFunction) {
+      return obj.object;
+    } else {
+      return obj;
+    }
+  }
+
+  function getBoundThis(obj) {
+    if (obj instanceof BoundFunction) {
+      return obj._this;
+    } else {
+      return globalContext;
+    }
+  }
+
+  function BoundFunction(_this, object) {
+    this._this = _this;
+    this.object = object;
+  }
+
   // Table for local objects and functions that are proxied.
   function ProxiedObjectTable() {
     // Name for debugging.
     this.name = 'js-ref';
 
     // Table from IDs to JS objects.
     this.map = {};
 
     // Generator for new IDs.
     this._nextId = 0;
@@ skipping 95 matching lines @@
   }
 
   ProxiedObjectTable.prototype._initialize = function () {
     // Configure this table's port to forward methods, getters, and setters
     // from the remote proxy to the local object.
     var table = this;
 
     this.port.receive(function (message) {
       // TODO(vsm): Support a mechanism to register a handler here.
       try {
-        var receiver = table.get(message[0]);
+        var object = table.get(message[0]);
+        var receiver = unbind(object);
         var member = message[1];
         var kind = message[2];
         var args = message[3].map(deserialize);
         if (kind == 'get') {
           // Getter.
           var field = member;
           if (field in receiver && args.length == 0) {
-            return [ 'return', serialize(receiver[field]) ];
+            var result = bindIfFunction(receiver[field], receiver);
+            return [ 'return', serialize(result) ];
           }
         } else if (kind == 'set') {
           // Setter.
           var field = member;
           if (args.length == 1) {
             return [ 'return', serialize(receiver[field] = args[0]) ];
           }
         } else if (kind == 'apply') {
           // Direct function invocation.
-          // TODO(vsm): Should we capture _this_ automatically?
-          return [ 'return', serialize(receiver.apply(null, args)) ];
+          var _this = getBoundThis(object);
+          return [ 'return', serialize(receiver.apply(_this, args)) ];
         } else if (member == '[]' && args.length == 1) {
           // Index getter.
-          return [ 'return', serialize(receiver[args[0]]) ];
+          var result = bindIfFunction(receiver[args[0]], receiver);
+          return [ 'return', serialize(result) ];
         } else if (member == '[]=' && args.length == 2) {
           // Index setter.
           return [ 'return', serialize(receiver[args[0]] = args[1]) ];
         } else {
+          // Member function invocation.
           var f = receiver[member];
           if (f) {
             var result = f.apply(receiver, args);
             return [ 'return', serialize(result) ];
           }
         }
         return [ 'none' ];
       } catch (e) {
         return [ 'throws', e.toString() ];
       }
@@ skipping 102 matching lines @@
                typeof(message) == 'number' ||
                typeof(message) == 'boolean') {
       // Primitives are passed directly through.
       return message;
     } else if (message instanceof SendPortSync) {
       // Non-proxied objects are serialized.
       return message;
     } else if (message instanceof Element &&
         (message.ownerDocument == null || message.ownerDocument == document)) {
       return [ 'domref', serializeElement(message) ];
+    } else if (message instanceof BoundFunction &&
+               typeof(message.object) == 'function') {
+      // Local function proxy.
+      return [ 'funcref',
+               proxiedObjectTable.add(message),
+               proxiedObjectTable.sendPort ];
     } else if (typeof(message) == 'function') {
       if ('_dart_id' in message) {
         // 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),
@@ skipping 70 matching lines @@
     } else {
       // Remote object.
       return new DartProxy(id, port);
     }
   }
 
   // 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];
+    var constructor = unbind(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, particulary 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]);
@@ skipping 48 matching lines @@
            ' (out of ' + total + ' ever allocated).';
   }
 
   // Return true if two JavaScript proxies are equal (==).
   function proxyEquals(args) {
     return deserialize(args[0]) == deserialize(args[1]);
   }
 
   // Return true if a JavaScript proxy is instance of a given type (instanceof).
   function proxyInstanceof(args) {
-    return deserialize(args[0]) instanceof deserialize(args[1]);
+    var obj = unbind(deserialize(args[0]));
+    var type = unbind(deserialize(args[1]));
+    return obj instanceof type;
   }
 
   // Return true if a JavaScript proxy is instance of a given type (instanceof).
   function proxyDeleteProperty(args) {
-    delete deserialize(args[0])[deserialize(args[1])];
+    var obj = unbind(deserialize(args[0]));
+    var member = unbind(deserialize(args[1]));
+    delete obj[member];
   }
 
   function proxyConvert(args) {
     return serialize(deserializeDataTree(args));
   }
 
   function deserializeDataTree(data) {
     var type = data[0];
     var value = data[1];
     if (type === 'map') {
@@ skipping 63 matching lines @@
     if (data[0] == "objref") return proxiedObjectTable.globalize(data[1]);
     // TODO(vsm): Do we ever need to globalize functions?
     throw 'Illegal type: ' + data[0];
   });
   makeGlobalPort('dart-js-invalidate', function(data) {
     if (data[0] == "objref") return proxiedObjectTable.invalidate(data[1]);
     // TODO(vsm): Do we ever need to globalize functions?
     throw 'Illegal type: ' + data[0];
   });
 })();