Allow sending static/top-level functions through ports and as isolate

sdk/lib/_internal/compiler/js_lib/isolate_helper.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.
 
 library _isolate_helper;
 
 import 'shared/embedded_names.dart' show
     CURRENT_SCRIPT,
     GLOBAL_FUNCTIONS;
 
@@ skipping 1350 matching lines @@
   }
 
   visitNativeJsSendPort(_NativeJsSendPort port) {
     return ['sendport', _globalState.currentManagerId,
         port._isolateId, port._receivePort._id];
   }
 
   visitWorkerSendPort(_WorkerSendPort port) {
     return ['sendport', port._workerId, port._isolateId, port._receivePortId];
   }
+
+  visitFunction(Function topLevelFunction) {
+    final name = IsolateNatives._getJSFunctionName(topLevelFunction);
+    if (name == null) {
+      throw new UnsupportedError(
+          "only top-level functions can be sent.");
+    }
+    return ['function', name];
+  }
 }
 
 
 class _JsCopier extends _Copier {
 
   _JsCopier() : super() { _visited = new _JsVisitedMap(); }
 
   visitSendPort(SendPort x) {
     if (x is _NativeJsSendPort) return visitNativeJsSendPort(x);
     if (x is _WorkerSendPort) return visitWorkerSendPort(x);
     throw "Illegal underlying port $x";
   }
 
   visitCapability(Capability x) {
     if (x is CapabilityImpl) {
       return new CapabilityImpl._internal(x._id);
     }
     throw "Capability not serializable: $x";
   }
 
   SendPort visitNativeJsSendPort(_NativeJsSendPort port) {
     return new _NativeJsSendPort(port._receivePort, port._isolateId);
   }
 
   SendPort visitWorkerSendPort(_WorkerSendPort port) {
     return new _WorkerSendPort(
         port._workerId, port._isolateId, port._receivePortId);
   }
+
+  Function visitFunction(Function topLevelFunction) {
+    final name = IsolateNatives._getJSFunctionName(topLevelFunction);
+    if (name == null) {
+      throw new UnsupportedError(
+          "only top-level functions can be sent.");
+    }
+    // Is this getting it from the correct isolate? Is it just topLevelFunction?
+    return IsolateNatives._getJSFunctionFromName(name);
+  }
 }
 
 class _JsDeserializer extends _Deserializer {
 
   SendPort deserializeSendPort(List list) {
     int managerId = list[1];
     int isolateId = list[2];
     int receivePortId = list[3];
     // If two isolates are in the same manager, we use NativeJsSendPorts to
     // deliver messages directly without using postMessage.
     if (managerId == _globalState.currentManagerId) {
       var isolate = _globalState.isolates[isolateId];
       if (isolate == null) return null; // Isolate has been closed.
       var receivePort = isolate.lookup(receivePortId);
       if (receivePort == null) return null; // Port has been closed.
       return new _NativeJsSendPort(receivePort, isolateId);
     } else {
       return new _WorkerSendPort(managerId, isolateId, receivePortId);
     }
   }
 
   Capability deserializeCapability(List list) {
     return new CapabilityImpl._internal(list[1]);
   }
+
+  Function deserializeFunction(List list) {
+    return IsolateNatives._getJSFunctionFromName(list[1]);
+  }
 }
 
 class _JsVisitedMap implements _MessageTraverserVisitedMap {
   List tagged;
 
   /** Retrieves any information stored in the native object [object]. */
   operator[](var object) {
     return _getAttachedInfo(object);
   }
 
@@ skipping 79 matching lines @@
   }
 
   _dispatch(var x) {
     // This code likely fails for user classes implementing
     // SendPort and Capability because it assumes the internal classes.
     if (isPrimitive(x)) return visitPrimitive(x);
     if (x is List) return visitList(x);
     if (x is Map) return visitMap(x);
     if (x is SendPort) return visitSendPort(x);
     if (x is Capability) return visitCapability(x);
+    if (x is Function) return visitFunction(x);
 
     // Overridable fallback.
     return visitObject(x);
   }
 
   visitPrimitive(x);
   visitList(List x);
   visitMap(Map x);
   visitSendPort(SendPort x);
   visitCapability(Capability x);
+  visitFunction(Function f);
 
   visitObject(Object x) {
     // TODO(floitsch): make this a real exception. (which one)?
     throw "Message serialization: Illegal value $x passed";
   }
 
   static bool isPrimitive(x) {
     return (x == null) || (x is String) || (x is num) || (x is bool);
   }
 }
@@ skipping 25 matching lines @@
 
     // TODO(floitsch): we loose the generic type of the map.
     copy = new Map();
     _visited[map] = copy;
     map.forEach((key, val) {
       copy[_dispatch(key)] = _dispatch(val);
     });
     return copy;
   }
 
+  visitFunction(Function f) => throw new UnimplementedError();
+
   visitSendPort(SendPort x) => throw new UnimplementedError();
 
   visitCapability(Capability x) => throw new UnimplementedError();
 }
 
 /** Visitor that serializes a message as a JSON array. */
 class _Serializer extends _MessageTraverser {
   int _nextFreeRefId = 0;
 
   visitPrimitive(x) => x;
@@ skipping 28 matching lines @@
     var result = new List()..length = len;
     for (int i = 0; i < len; i++) {
       result[i] = _dispatch(list[i]);
     }
     return result;
   }
 
   visitSendPort(SendPort x) => throw new UnimplementedError();
 
   visitCapability(Capability x) => throw new UnimplementedError();
+
+  visitFunction(Function f) => throw new UnimplementedError();
 }
 
 /** Deserializes arrays created with [_Serializer]. */
 abstract class _Deserializer {
   Map<int, dynamic> _deserialized;
 
   _Deserializer();
 
   static bool isPrimitive(x) {
     return (x == null) || (x is String) || (x is num) || (x is bool);
   }
 
   deserialize(x) {
     if (isPrimitive(x)) return x;
     // TODO(floitsch): this should be new HashMap<int, dynamic>()
     _deserialized = new HashMap();
     return _deserializeHelper(x);
   }
 
   _deserializeHelper(x) {
     if (isPrimitive(x)) return x;
     assert(x is List);
     switch (x[0]) {
       case 'ref': return _deserializeRef(x);
       case 'list': return _deserializeList(x);
       case 'map': return _deserializeMap(x);
       case 'sendport': return deserializeSendPort(x);
       case 'capability': return deserializeCapability(x);
+      case 'function' : return deserializeFunction(x);
       default: return deserializeObject(x);
     }
   }
 
   _deserializeRef(List x) {
     int id = x[1];
     var result = _deserialized[id];
     assert(result != null);
     return result;
   }
@@ skipping 19 matching lines @@
     int len = keys.length;
     assert(len == values.length);
     for (int i = 0; i < len; i++) {
       var key = _deserializeHelper(keys[i]);
       var value = _deserializeHelper(values[i]);
       result[key] = value;
     }
     return result;
   }
 
+  deserializeFunction(List x);
+
   deserializeSendPort(List x);
 
   deserializeCapability(List x);
 
   deserializeObject(List x) {
     // TODO(floitsch): Use real exception (which one?).
     throw "Unexpected serialized object";
   }
 }
 
@@ skipping 111 matching lines @@
   }
 
   bool operator==(Object other) {
     if (identical(other, this)) return true;
     if (other is CapabilityImpl) {
       return identical(_id, other._id);
     }
     return false;
   }
 }