Share code between the transformer isolate and pub proper.

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

+// 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.exception;
+
+import 'package:barback/barback.dart';
+import 'package:stack_trace/stack_trace.dart';
+
+import '../utils.dart';
+
+/// An exception that was originally raised in another isolate.
+///
+/// Exception objects can't cross isolate boundaries in general, so this class
+/// wraps as much information as can be consistently serialized.
+class CrossIsolateException implements Exception {
+  /// The name of the type of exception thrown.
+  ///
+  /// This is the return value of [error.runtimeType.toString()]. Keep in mind
+  /// that objects in different libraries may have the same type name.
+  final String type;
+
+  /// The exception's message, or its [toString] if it didn't expose a `message`
+  /// property.
+  final String message;
+
+  /// The exception's stack chain, or `null` if no stack chain was available.
+  final Chain stackTrace;
+
+  /// Loads a [CrossIsolateException] from a serialized representation.
+  ///
+  /// [error] should be the result of [CrossIsolateException.serialize].
+  CrossIsolateException.deserialize(Map error)
+      : type = error['type'],
+        message = error['message'],
+        stackTrace = error['stack'] == null ? null :
+            new Chain.parse(error['stack']);
+
+  /// Serializes [error] to an object that can safely be passed across isolate
+  /// boundaries.
+  static Map serialize(error, [StackTrace stack]) {
+    if (stack == null && error is Error) stack = error.stackTrace;
+    return {
+      'type': error.runtimeType.toString(),
+      'message': getErrorMessage(error),
+      'stack': stack == null ? null : new Chain.forTrace(stack).toString()
+    };
+  }
+
+  String toString() => "$message\n$stackTrace";
+}
+
+/// An [AssetNotFoundException] that was originally raised in another isolate. 
+class _CrossIsolateAssetNotFoundException extends CrossIsolateException
+    implements AssetNotFoundException {
+  final AssetId id;
+
+  String get message => "Could not find asset $id.";
+
+  /// Loads a [_CrossIsolateAssetNotFoundException] from a serialized
+  /// representation.
+  ///
+  /// [error] should be the result of
+  /// [_CrossIsolateAssetNotFoundException.serialize].
+  _CrossIsolateAssetNotFoundException.deserialize(Map error)
+      : id = new AssetId(error['package'], error['path']),
+        super.deserialize(error);
+
+  /// Serializes [error] to an object that can safely be passed across isolate
+  /// boundaries.
+  static Map serialize(AssetNotFoundException error, [StackTrace stack]) {
+    var map = CrossIsolateException.serialize(error);
+    map['package'] = error.id.package;
+    map['path'] = error.id.path;
+    return map;
+  }
+}
+
+/// Serializes [error] to an object that can safely be passed across isolate
+/// boundaries.
+///
+/// This handles [AssetNotFoundException]s specially, ensuring that their
+/// metadata is preserved.
+Map serializeException(error, [StackTrace stack]) {
+  if (error is AssetNotFoundException) {
+    return _CrossIsolateAssetNotFoundException.serialize(error, stack);
+  } else {
+    return CrossIsolateException.serialize(error, stack);
+  }
+}
+
+/// Loads an exception from a serialized representation.
+///
+/// This handles [AssetNotFoundException]s specially, ensuring that their
+/// metadata is preserved.
+CrossIsolateException deserializeException(Map error) {
+  if (error['type'] == 'AssetNotFoundException') {
+    return new _CrossIsolateAssetNotFoundException.deserialize(error);
+  } else {
+    return new CrossIsolateException.deserialize(error);
+  }
+}