Support general serializing of functions between JS and Dart

lib/html/src/Isolates.dart

 // 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.
 
 _serialize(var message) {
   return new _JsSerializer().traverse(message);
 }
 
 class _JsSerializer extends _Serializer {
 
@@ skipping 11 matching lines @@
   visitLocalSendPortSync(_LocalSendPortSync x) {
     return [ 'sendport', 'dart',
              ReceivePortSync._isolateId, x._receivePort._portId ];
   }
 
   visitRemoteSendPortSync(_RemoteSendPortSync x) {
     return [ 'sendport', 'dart',
              x._receivePort._isolateId, x._receivePort._portId ];
   }
 
+  visitObject(Object x) {
+    if (x is Function) return visitFunction(x);
+    // TODO: Handle DOM elements and proxy other objects.
+    throw "Unserializable object $x";
+ }
+
   visitFunction(Function func) {
     return [ 'funcref',
               _makeFunctionRef(func), visitSendPortSync(_sendPort()), null ];
   }
 }
 
 // Leaking implementation.  Later will be backend specific and hopefully
 // not leaking (at least in most of the cases.)
 // TODO: provide better, backend specific implementation.
 class _FunctionRegistry {
@@ skipping 38 matching lines @@
 _makeFunctionRef(f) => _functionRegistry._add(f);
 _sendPort() => _functionRegistry._sendPort;
 /// End of function serialization implementation.
 
 _deserialize(var message) {
   return new _JsDeserializer().deserialize(message);
 }
 
 class _JsDeserializer extends _Deserializer {
 
+  static final _UNSPECIFIED = const Object();
+
   deserializeSendPort(List x) {
     String tag = x[1];
     switch (tag) {
       case 'nativejs':
         num id = x[2];
         return new _JsSendPortSync(id);
       case 'dart':
         num isolateId = x[2];
         num portId = x[3];
         return ReceivePortSync._lookup(isolateId, portId);
       default:
         throw 'Illegal SendPortSync type: $tag';
     }
   }
 
+  deserializeObject(List x) {
+    String tag = x[0];
+    switch (tag) {
+      case 'funcref': return deserializeFunction(x);
+      default: throw 'Illegal object type: $x';
+    }
+  }
+
+  deserializeFunction(List x) {
+    var id = x[1];
+    SendPortSync port = deserializeSendPort(x[2]);
+    // TODO: Support varargs when there is support in the language.
+    var f = ([arg0 = _UNSPECIFIED, arg1 = _UNSPECIFIED,

[Anton Muhin, 2012/08/21 11:27:35]

nit: I'd not introduce f local and would just return function expression, but I
know I favour too much terse syntax.

[vsm, 2012/08/21 15:59:26]

Done.

+              arg2 = _UNSPECIFIED, arg3 = _UNSPECIFIED]) {
+      var args = [arg0, arg1, arg2, arg3];
+      var last = args.indexOf(_UNSPECIFIED);
+      if (last >= 0) args.removeRange(last, args.length - 1);

[Anton Muhin, 2012/08/21 11:27:35]

getRange(0, last) is slightly more readable, but YMMV

[vsm, 2012/08/21 15:59:26]

Done.

+      var message = [id, args];
+      return port.callSync(message);
+    };
+    return f;
+  }
 }
 
 // The receiver is JS.
 class _JsSendPortSync implements SendPortSync {
 
   num _id;
   _JsSendPortSync(this._id);
 
   callSync(var message) {
     var serialized = _serialize(message);
@@ skipping 122 matching lines @@
       return new _RemoteSendPortSync(isolateId, portId);
     }
   }
 }
 
 void _dispatchEvent(String receiver, var message) {
   var event = document.$dom_createEvent('TextEvent');
   event.initTextEvent(receiver, false, false, window, JSON.stringify(message));
   window.$dom_dispatchEvent(event);
 }