Cache function proxies

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 JsProxy {
   SendPortSync _port;
@@ skipping 60 matching lines @@
     if (x is JsProxy) return visitJsProxy(x);
     if (x is Element) return visitElement(x);
 
     // TODO: Handle DOM elements and proxy other objects.
     var proxyId = _dartProxyRegistry._add(x);
     return [ 'objref', proxyId,
              visitSendPortSync(_dartProxyRegistry._sendPort) ];
  }
 
   visitFunction(Function func) {
+    // Look for a cached serialization first.  The cached version
+    // should point to the original port.
+    var serialized = _deserializedFunctionTable.find(func);
+    if (serialized != null) return serialized;
+    // Create a new serialization forwarding to this port.
     return [ 'funcref',
              _functionRegistry._add(func),
              visitSendPortSync(_functionRegistry._sendPort), null ];
   }
 
   visitJsProxy(JsProxy proxy) {
     return [ 'objref', proxy._id, visitSendPortSync(proxy._port) ];
   }
 
   visitElement(Element element) {
@@ skipping 76 matching lines @@
   }
   return __dartProxyRegistry;
 }
 
 /// End of object proxy implementation.
 
 _deserialize(var message) {
   return new _JsDeserializer().deserialize(message);
 }
 
+// TODO(vsm): Replace this with a hash map once functions are
+// hashable.
+class _DeserializedFunctionTable {
+  List data;
+  _DeserializedFunctionTable() {
+    data = [];
+  }
+
+  find(Function f) {
+    for (var item in data) {
+      if (f == item[0]) return item[1];
+    }
+    return null;
+  }
+
+  add(Function f, x) {
+    data.add([f, x]);
+  }
+}
+
+_DeserializedFunctionTable __deserializedFunctionTable = null;
+get _deserializedFunctionTable {
+  if (__deserializedFunctionTable == null) {
+    __deserializedFunctionTable = new _DeserializedFunctionTable();
+  }
+  return __deserializedFunctionTable;
+}
+
 class _JsDeserializer extends _Deserializer {
 
   static const _UNSPECIFIED = const Object();
 
   deserializeSendPort(List x) {
     String tag = x[1];
     switch (tag) {
       case 'nativejs':
         num id = x[2];
         return new _JsSendPortSync(id);
@@ skipping 11 matching lines @@
     switch (tag) {
       case 'funcref': return deserializeFunction(x);
       case 'objref': return deserializeProxy(x);
       case 'element': return deserializeElement(x);
       default: throw 'Illegal object type: $x';
     }
   }
 
   deserializeFunction(List x) {
     var id = x[1];
+    // If the sendPort is local, just return the underlying function.
+    // Otherwise, create a new function that forwards to the remote
+    // port.
     SendPortSync port = deserializeSendPort(x[2]);
+    if (port is _LocalSendPortSync) {
+      return _functionRegistry._get(id);
+    }
     // TODO: Support varargs when there is support in the language.
-    return ([arg0 = _UNSPECIFIED, arg1 = _UNSPECIFIED,
+    var f = ([arg0 = _UNSPECIFIED, arg1 = _UNSPECIFIED,
               arg2 = _UNSPECIFIED, arg3 = _UNSPECIFIED]) {
       var args = [arg0, arg1, arg2, arg3];
       var last = args.indexOf(_UNSPECIFIED);
       if (last >= 0) args = args.getRange(0, last);
       var message = [id, args];
       return port.callSync(message);
     };
+    _deserializedFunctionTable.add(f, x);
+    return f;
   }
 
   deserializeProxy(x) {
     var id = x[1];
     var port = deserializeSendPort(x[2]);
     if (port is _JsSendPortSync) return new JsProxy._internal(port, id);
     if (port is _LocalSendPortSync) return _dartProxyRegistry._get(id);
     // TODO(vsm): Support this case.
     if (port is _RemoteSendPortSync) throw 'Remote Dart proxies unsupported';
     throw 'Illegal proxy: $port';
@@ skipping 140 matching lines @@
   }
 }
 
 get _isolateId => ReceivePortSync._isolateId;
 
 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);
 }