Remove streamSpawnUri and mangler.

sdk/lib/_internal/compiler/implementation/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 'dart:async';
 import 'dart:collection' show Queue, HashMap;
 import 'dart:isolate';
 import 'dart:_js_helper' show convertDartClosureToJS,
                               Null;
 import 'dart:_foreign_helper' show DART_CLOSURE_TO_JS,
                                    JS,
                                    JS_CREATE_ISOLATE,
                                    JS_CURRENT_ISOLATE,
                                    JS_SET_CURRENT_ISOLATE,
                                    IsolateContext;
 
 ReceivePort lazyPort;
 
+class CloseToken {
+  /// This token is sent from [IsolateSink]s to [IsolateStream]s to ask them to
+  /// close themselves.
+  const CloseToken();
+}
+
+class JsIsolateSink extends StreamSink<dynamic> implements IsolateSink {
+  bool _isClosed = false;
+  final SendPort _port;
+  JsIsolateSink.fromPort(this._port);
+
+  void add(dynamic message) {
+    _port.send(message);
+  }
+
+  void addError(AsyncError errorEvent) {
+    throw new UnimplementedError("signalError on isolate streams");
+  }
+
+  void close() {
+    if (_isClosed) return;
+    add(const CloseToken());
+    _isClosed = true;
+  }
+
+  bool operator==(var other) {
+    return other is IsolateSink && _port == other._port;
+  }
+
+  int get hashCode => _port.hashCode + 499;
+}
+
 /**
  * Called by the compiler to support switching
  * between isolates when we get a callback from the DOM.
  */
 void _callInIsolate(_IsolateContext isolate, Function function) {
   isolate.eval(function);
   _globalState.topEventLoop.run();
 }
 
 /**
@@ skipping 868 matching lines @@
     // TODO(sigmund): replace with the following: (bug #1660)
     // map.values.forEach(_dispatch);
     map.values.forEach((e) => _dispatch(e));
   }
 
   visitSendPort(SendPort port) {
     if (port is _BufferingSendPort && port._port == null) {
       ports.add(port._futurePort);
     }
   }
+
+  visitIsolateSink(IsolateSink sink) {
+    visitSendPort(sink._port);
+  }
+
+  visitCloseToken(CloseToken token) {
+    // Do nothing.
+  }
 }
 
 /********************************************************
   Inserted from lib/isolate/dart2js/messages.dart
  ********************************************************/
 
 // Defines message visitors, serialization, and deserialization.
 
 /** Serialize [message] (or simulate serialization). */
 _serializeMessage(message) {
@@ skipping 38 matching lines @@
     if (port._port != null) {
       return visitSendPort(port._port);
     } else {
       // TODO(floitsch): Use real exception (which one?).
       throw
           "internal error: must call _waitForPendingPorts to ensure all"
           " ports are resolved at this point.";
     }
   }
 
+  visitIsolateSink(IsolateSink sink) {
+    SendPort port = sink._port;
+    bool isClosed = sink._isClosed;
+    return ['isolateSink', visitSendPort(port), isClosed];
+  }
+
+  visitCloseToken(CloseToken token) {
+    return ['closeToken'];
+  }
 }
 
 
 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);
@@ skipping 14 matching lines @@
     if (port._port != null) {
       return visitSendPort(port._port);
     } else {
       // TODO(floitsch): Use real exception (which one?).
       throw
           "internal error: must call _waitForPendingPorts to ensure all"
           " ports are resolved at this point.";
     }
   }
 
+  IsolateSink visitIsolateSink(IsolateSink sink) {
+    SendPort port = sink._port;
+    bool isClosed = sink._isClosed;
+    IsolateSink result = new JsIsolateSink.fromPort(visitSendPort(port));
+    result._isClosed = isClosed;
+    return result;
+  }
+
+  CloseToken visitCloseToken(CloseToken token) {
+    return token;  // Can be shared.
+  }
 }
 
 class _JsDeserializer extends _Deserializer {
 
   SendPort deserializeSendPort(List x) {
     int managerId = x[1];
     int isolateId = x[2];
     int receivePortId = x[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);
     }
   }
 
+  IsolateSink deserializeIsolateSink(List x) {

[Lasse Reichstein Nielsen, 2013/03/19 12:01:55]

Better name than 'x', please.

[floitsch, 2013/03/19 13:18:59]

Done.

+    SendPort port = deserializeSendPort(x[1]);
+    bool isClosed = x[2];
+    IsolateSink result = new JsIsolateSink.fromPort(port);
+    result._isClosed = isClosed;
+    return result;
+  }
+
+  CloseToken deserializeCloseToken(List x) {
+    return const CloseToken();
+  }
 }
 
 class _JsVisitedMap implements _MessageTraverserVisitedMap {
   List tagged;
 
   /** Retrieves any information stored in the native object [object]. */
   operator[](var object) {
     return _getAttachedInfo(object);
   }
 
@@ skipping 77 matching lines @@
     }
     return result;
   }
 
   _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 SendPort) return visitSendPort(x);
     if (x is SendPortSync) return visitSendPortSync(x);
+    if (x is JsIsolateSink) return visitIsolateSink(x);
+    if (x is CloseToken) return visitCloseToken(x);
 
     // Overridable fallback.
     return visitObject(x);
   }
 
   visitPrimitive(x);
   visitList(List x);
   visitMap(Map x);
   visitSendPort(SendPort x);
   visitSendPortSync(SendPortSync x);
+  visitIsolateSink(IsolateSink x);
+  visitCloseToken(CloseToken x);
 
   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 91 matching lines @@
   }
 
   _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 'isolateSink': return deserializeIsolateSink(x);
+      case 'closeToken': return deserializeCloseToken(x);
       default: return deserializeObject(x);
     }
   }
 
   _deserializeRef(List x) {
     int id = x[1];
     var result = _deserialized[id];
     assert(result != null);
     return result;
   }
@@ skipping 21 matching lines @@
     for (int i = 0; i < len; i++) {
       var key = _deserializeHelper(keys[i]);
       var value = _deserializeHelper(values[i]);
       result[key] = value;
     }
     return result;
   }
 
   deserializeSendPort(List x);
 
+  deserializeIsolateSink(List x);
+
+  deserializeCloseToken(List x);
+
   deserializeObject(List x) {
     // TODO(floitsch): Use real exception (which one?).
     throw "Unexpected serialized object";
   }
 }
 
 class TimerImpl implements Timer {
   final bool _once;
   bool _inEventLoop = false;
   int _handle;
@@ skipping 53 matching lines @@
         JS('void', '#.clearInterval(#)', globalThis, _handle);
       }
       _handle = null;
     } else {
       throw new UnsupportedError("Canceling a timer.");
     }
   }
 }
 
 bool hasTimer() => JS('', '#.setTimeout', globalThis) != null;