Isolates in frog - tweaks in existing js code to make things run

frog/lib/isolate.dart

 // Copyright (c) 2011, 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.
 
 class SendPortImpl implements SendPort {
 
   const SendPortImpl(this._workerId, this._isolateId, this._receivePortId);
 
   void send(var message, [SendPort replyTo = null]) {
-    // TODO(kasperl): get rid of _sendNow.
-    this._sendNow(message, replyTo);
+    if (replyTo !== null && !(replyTo is SendPortImpl)) {
+      throw "SendPort::send: Illegal replyTo type.";

[Jennifer Messerly, 2011/11/08 05:04:35]

probably want to throw an actual exception type?

[Siggi Cherem (dart-lang), 2011/11/08 17:56:42]

will do - the current throw was basically copied over from the JS code.

+    }
+    IsolateNatives.sendMessage(_workerId, _isolateId, _receivePortId,
+        _serializeMessage(message), _serializeMessage(replyTo));
   }
 
-  void _sendNow(var message, SendPort replyTo) native;
+  // TODO(sigmund): get rid of _sendNow

[Jennifer Messerly, 2011/11/08 05:04:35]

I think you can just remove it? I didn't see any callers.

[Siggi Cherem (dart-lang), 2011/11/08 17:56:42]

Unfortunately some other code in corelib is still using this, I'll remove it
after I clean up that code.

+  void _sendNow(var message, replyTo) { send(message, replyTo); }
+
+  _serializeMessage(message) {
+    if (IsolateNatives.shouldSerialize) {
+      return _IsolateJsUtil._serializeObject(message);
+    } else {
+      return _IsolateJsUtil._copyObject(message);
+    }
+  }
 
   ReceivePortSingleShotImpl call(var message) {
     final result = new ReceivePortSingleShotImpl();
     this.send(message, result.toSendPort());
     return result;
   }
 
   ReceivePortSingleShotImpl _callNow(var message) {
     final result = new ReceivePortSingleShotImpl();
-    this._sendNow(message, result.toSendPort());
+    send(message, result.toSendPort());
     return result;
   }
 
   bool operator==(var other) {
     return (other is SendPortImpl) &&
         (_workerId == other._workerId) &&
         (_isolateId == other._isolateId) &&
         (_receivePortId == other._receivePortId);
   }
 
@@ skipping 29 matching lines @@
   factory ReceivePort.singleShot() {
     return new ReceivePortSingleShotImpl();
   }
 
 }
 
 
 class ReceivePortImpl implements ReceivePort {
   ReceivePortImpl()
       : _id = _nextFreeId++ {
-    _register(_id);
+    IsolateNatives.registerPort(_id, this);
   }
 
   void receive(void onMessage(var message, SendPort replyTo)) {
     _callback = onMessage;
   }
 
   void close() {
     _callback = null;
-    _unregister(_id);
+    IsolateNatives.unregisterPort(_id);
   }
 
   SendPort toSendPort() {
     return _toNewSendPort();
   }
 
   /**
    * Returns a fresh [SendPort]. The implementation is not allowed to cache
    * existing ports.
    */
   SendPort _toNewSendPort() {
-    return new SendPortImpl(_currentWorkerId(), _currentIsolateId(), _id);
+    return new SendPortImpl(
+        IsolateNatives._currentWorkerId(),
+        IsolateNatives._currentIsolateId(), _id);
   }
 
   int _id;
-  Function _callback = null;
+  Function _callback;
 
   static int _nextFreeId = 1;
 
-  void _register(int id) native;
-  void _unregister(int id) native;
-
-  static int _currentWorkerId() native;
-  static int _currentIsolateId() native;
-
-  static void _invokeCallback(ReceivePortImpl port, message, replyTo) native {
-    if (port._callback !== null) (port._callback)(message, replyTo);
-  }
-
   static int _getId(ReceivePortImpl port) native {
     return port._id;
   }
+
   static Function _getCallback(ReceivePortImpl port) native {
     return port._callback;
   }
 }
 
 
 class ReceivePortSingleShotImpl implements ReceivePort {
 
   ReceivePortSingleShotImpl() : _port = new ReceivePortImpl() { }
 
@@ skipping 19 matching lines @@
   SendPort _toNewSendPort() {
     return _port._toNewSendPort();
   }
 
   final ReceivePortImpl _port;
 
 }
 
 final String _SPAWNED_SIGNAL = "spawned";
 
-class IsolateNatives {
+class IsolateNatives native "IsolateNatives" {
   static Future<SendPort> spawn(Isolate isolate, bool isLight) {
     Completer<SendPort> completer = new Completer<SendPort>();
     ReceivePort port = new ReceivePort.singleShot();
     port.receive((msg, SendPort replyPort) {
       assert(msg == _SPAWNED_SIGNAL);
       completer.complete(replyPort);
     });
     _spawn(isolate, isLight, port.toSendPort());
+    if (false) {
+      // TODO(sigmund): delete this code. This is temporarily added because we
+      // are tree-shaking methods that are only reachable from js
+      _IsolateJsUtil._startIsolate(null, null);
+      _IsolateJsUtil._deserializeMessage(null);
+      _IsolateJsUtil._print(null);
+    }
     return completer.future;
   }
 
   static SendPort _spawn(Isolate isolate, bool light, SendPort port) native;
-  static Function bind(Function f) native;
+
+  static bool get shouldSerialize() native;
+
+  static void sendMessage(int workerId, int isolateId, int receivePortId,
+      message, replyTo) native;
+
+  /** Registers an active receive port. */
+  static void registerPort(int id, ReceivePort port) native;
+
+  /** Unregister an inactive receive port. */
+  static void unregisterPort(int id) native;
+
+  static int _currentWorkerId() native;
+
+  static int _currentIsolateId() native;
 }
 
 
-class _IsolateJsUtil {
+class _IsolateJsUtil native "_IsolateJsUtil" {
   static void _startIsolate(Isolate isolate, SendPort replyTo) native {
     ReceivePort port = new ReceivePort();
     replyTo.send(_SPAWNED_SIGNAL, port.toSendPort());
     isolate._run(port);
   }
 
-  static SendPort _toSendPort(port) native {
-    return port.toSendPort();
-  }
-
   static void _print(String msg) native {
     print(msg);
   }
 
   static _copyObject(obj) native {
     return new Copier().traverse(obj);
   }
 
   static _serializeObject(obj) native {
     return new Serializer().traverse(obj);
   }
 
   static _deserializeMessage(message) native {
     return new Deserializer().deserialize(message);
   }
 }