isolate lib: small refactor to distinguish protocols at the port level

frog/lib/isolate_serialization.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.
 
 /**
  * Abstract visitor for dart objects that can be passed as messages between any
  * isolates.
  */
 class MessageTraverser {
   static bool isPrimitive(x) {
@@ skipping 32 matching lines @@
 
   /** Retrieves any information stored in the native object [o]. */
   _getInfo(var o) {
     return _getAttachedInfo(o);
   }
 
   _dispatch(var x) {
     if (isPrimitive(x)) return visitPrimitive(x);
     if (x is List) return visitList(x);
     if (x is Map) return visitMap(x);
-    if (x is SendPortImpl) return visitSendPort(x);
+    if (x is NativeJsSendPort) return visitNativeJsSendPort(x);
+    if (x is WorkerSendPort) return visitWorkerSendPort(x);
     if (x is ReceivePortImpl) return visitReceivePort(x);
     if (x is ReceivePortSingleShotImpl) return visitReceivePortSingleShot(x);
     // TODO(floitsch): make this a real exception. (which one)?
     throw "Message serialization: Illegal value $x passed";
   }
 
   abstract visitPrimitive(x);
   abstract visitList(List x);
   abstract visitMap(Map x);
-  abstract visitSendPort(SendPortImpl x);
+  abstract visitNativeJsSendPort(NativeJsSendPort x);
+  abstract visitWorkerSendPort(WorkerSendPort x);
   abstract visitReceivePort(ReceivePortImpl x);
   abstract visitReceivePortSingleShot(ReceivePortSingleShotImpl x);
 
   List _taggedObjects;
 
   _clearAttachedInfo(var o) native
       "o['__MessageTraverser__attached_info__'] = (void 0);";
 
   _setAttachedInfo(var o, var info) native
       "o['__MessageTraverser__attached_info__'] = info;";
@@ skipping 29 matching lines @@
 
     // TODO(floitsch): we loose the generic type of the map.
     copy = new Map();
     _attachInfo(map, copy);
     map.forEach((key, val) {
       copy[_dispatch(key)] = _dispatch(val);
     });
     return copy;
   }
 
-  SendPort visitSendPort(SendPortImpl port) {
-    return new SendPortImpl(port._workerId,
-                            port._isolateId,
-                            port._receivePortId);
+  SendPort visitNativeJsSendPort(NativeJsSendPort port) {
+    return new NativeJsSendPort(port._receivePort, port._isolateId);
+  }
+
+  SendPort visitWorkerSendPort(WorkerSendPort port) {
+    return new WorkerSendPort(
+        port._workerId, port._isolateId, port._receivePortId);
   }
 
   SendPort visitReceivePort(ReceivePortImpl port) {
     return port.toSendPort();
   }
 
   SendPort visitReceivePortSingleShot(ReceivePortSingleShotImpl port) {
     return port.toSendPort();
   }
 }
@@ skipping 20 matching lines @@
     if (copyId !== null) return ['ref', copyId];
 
     int id = _nextFreeRefId++;
     _attachInfo(map, id);
     var keys = _serializeList(map.getKeys());
     var values = _serializeList(map.getValues());
     // TODO(floitsch): we are losing the generic type.
     return ['map', id, keys, values];
   }
 
-  visitSendPort(SendPortImpl port) {
+  visitNativeJsSendPort(NativeJsSendPort port) {
+    return ['sendport', _globalState.currentWorkerId,
+        port._isolateId, port._receivePort._id];
+  }
+
+  visitWorkerSendPort(WorkerSendPort port) {
     return ['sendport', port._workerId, port._isolateId, port._receivePortId];
   }
 
   visitReceivePort(ReceivePortImpl port) {
-    return visitSendPort(port.toSendPort());;
+    return visitNativeJsSendPort(port.toSendPort());;
   }
 
   visitReceivePortSingleShot(ReceivePortSingleShotImpl port) {
-    return visitSendPort(port.toSendPort());
+    return visitNativeJsSendPort(port.toSendPort());
   }
 
   _serializeList(List list) {
     int len = list.length;
     var result = new List(len);
     for (int i = 0; i < len; i++) {
       result[i] = _dispatch(list[i]);
     }
     return result;
   }
@@ skipping 61 matching lines @@
       var value = _deserializeHelper(values[i]);
       result[key] = value;
     }
     return result;
   }
 
   SendPort _deserializeSendPort(List x) {
     int workerId = x[1];
     int isolateId = x[2];
     int receivePortId = x[3];
-    return new SendPortImpl(workerId, isolateId, receivePortId);
+    if (workerId == _globalState.currentWorkerId) {

[eub, 2012/02/09 01:13:42]

Do we want to distinguish the serialization token string between the two types
of send ports instead of using this somewhat magic test?  Or is the magic better
since non-redundant?

[Siggi Cherem (dart-lang), 2012/02/10 00:16:41]

The magic is actually important for two reasons: check that we only create a
native port when we are in the correct worker (the redundancy issue you raised),
and normalize how ports are used. For the latter, we want to 'short-circuit'
ports that come back to the same worker. If I have 3 isolates, with A and B in
the same worker and C in a different one, then passing a port from A to C to B
should create a direct (nativejs) port B->A.

+      var isolate = _globalState.isolates[isolateId];
+      if (isolate == null) return null; // Isolate has been closed.
+      var receivePort = isolate.lookup(receivePortId);
+      return new NativeJsSendPort(receivePort, isolateId);
+    } else {
+      return new WorkerSendPort(workerId, isolateId, receivePortId);
+    }
   }
 
   // TODO(floitsch): this should by Map<int, var> or Map<int, Dynamic>.
   Map<int, Dynamic> _deserialized;
 }