Share code between the transformer isolate and pub proper.

sdk/lib/_internal/pub/asset/dart/serialize.dart

Index: sdk/lib/_internal/pub/asset/dart/serialize.dart
diff --git a/sdk/lib/_internal/pub/asset/dart/serialize.dart b/sdk/lib/_internal/pub/asset/dart/serialize.dart
new file mode 100644
index 0000000000000000000000000000000000000000..43328e141be23978bfacfb1d36d320ec860f8992
--- /dev/null
+++ b/sdk/lib/_internal/pub/asset/dart/serialize.dart
@@ -0,0 +1,100 @@
+// Copyright (c) 2014, 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 pub.asset.serialize;
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:barback/barback.dart';
+import 'package:source_maps/span.dart';
+
+import 'serialize/exception.dart';
+
+export 'serialize/exception.dart';
+export 'serialize/transform.dart';
+export 'serialize/transformer.dart';
+
+/// Converts [id] into a serializable map.
+Map serializeId(AssetId id) => {'package': id.package, 'path': id.path};
+
+/// Converts a serializable map into an [AssetId].
+AssetId deserializeId(Map id) => new AssetId(id['package'], id['path']);
+
+/// Converts [span] into a serializable map.
+Map serializeSpan(Span span) {
+  // TODO(nweiz): convert FileSpans to FileSpans.
+  return {
+    'type': 'fixed',
+    'sourceUrl': span.sourceUrl,
+    'start': serializeLocation(span.start),
+    'text': span.text,
+    'isIdentifier': span.isIdentifier
+  };
+}
+
+/// Converts a serializable map into a [Span].
+Span deserializeSpan(Map span) {
+  assert(span['type'] == 'fixed');
+  var location = deserializeLocation(span['start']);
+  return new FixedSpan(span['sourceUrl'], location.offset, location.line,
+      location.column, text: span['text'], isIdentifier: span['isIdentifier']);
+}
+
+/// Converts [location] into a serializable map.
+Map serializeLocation(Location location) {
+  // TODO(nweiz): convert FileLocations to FileLocations.
+  return {
+    'type': 'fixed',
+    'sourceUrl': location.sourceUrl,
+    'offset': location.offset,
+    'line': location.line,
+    'column': location.column
+  };
+}
+
+/// Converts a serializable map into a [Location].
+Location deserializeLocation(Map location) {
+  assert(location['type'] == 'fixed');
+  return new FixedLocation(location['offset'], location['sourceUrl'],
+      location['line'], location['column']);
+}
+
+/// Wraps [message] and sends it across [port], then waits for a response which
+/// should be sent using [respond].
+///
+/// The returned Future will complete to the value or error returned by
+/// [respond].
+Future call(SendPort port, message) {
+  var receivePort = new ReceivePort();
+  port.send({
+    'message': message,
+    'replyTo': receivePort.sendPort
+  });
+
+  return receivePort.first.then((response) {
+    if (response['type'] == 'success') return response['value'];
+    assert(response['type'] == 'error');
+    var exception = deserializeException(response['error']);
+    return new Future.error(exception, exception.stackTrace);
+  });
+}
+
+/// Responds to a message sent by [call].
+///
+/// [wrappedMessage] is the raw message sent by [call]. This unwraps it and
+/// passes the contents of the message to [callback], then sends the return
+/// value of [callback] back to [call]. If [callback] returns a Future or
+/// throws an error, that will also be sent.
+void respond(wrappedMessage, callback(message)) {
+  var replyTo = wrappedMessage['replyTo'];
+  new Future.sync(() => callback(wrappedMessage['message']))
+      .then((result) => replyTo.send({'type': 'success', 'value': result}))
+      .catchError((error, stackTrace) {
+    replyTo.send({
+      'type': 'error',
+      'error': serializeException(error, stackTrace)
+    });
+  });
+}