Add a stack chain class to the stack trace package.

pkg/stack_trace/lib/src/trace.dart

 // Copyright (c) 2013, 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 trace;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
+import 'chain.dart';
 import 'frame.dart';
 import 'lazy_trace.dart';
 import 'utils.dart';
 import 'vm_trace.dart';
 
 final _terseRegExp = new RegExp(r"(-patch)?(/.*)?$");
 
 /// A RegExp to match V8's stack traces.
 ///
 /// V8's traces start with a line that's either just "Error" or else is a
@@ skipping 65 matching lines @@
       return new LazyTrace(() => new Trace(trace.frames.skip(level + 1)));
     }
   }
 
   /// Returns a new stack trace containing the same data as [trace].
   ///
   /// If [trace] is a native [StackTrace], its data will be parsed out; if it's
   /// a [Trace], it will be returned as-is.
   factory Trace.from(StackTrace trace) {
     if (trace is Trace) return trace;
+    if (trace is Chain) return trace.toTrace();
     return new LazyTrace(() => new Trace.parse(trace.toString()));
   }
 
   /// Parses a string representation of a stack trace.
   ///
   /// [trace] should be formatted in the same way as a Dart VM or browser stack
   /// trace.
   factory Trace.parse(String trace) {
     try {
       if (trace.isEmpty) return new Trace(<Frame>[]);
@@ skipping 60 matching lines @@
   ///
   /// Safari 6.0 stack traces look just like Firefox traces, except that they
   /// sometimes (e.g. in isolates) have a "[native code]" frame. We just ignore
   /// this frame to make the stack format more consistent between browsers.
   /// Prior to Safari 6.0, stack traces can't be retrieved.
   Trace.parseSafari6_0(String trace)
       : this(trace.trim().split("\n")
           .where((line) => line != '[native code]')
           .map((line) => new Frame.parseFirefox(line)));
 
-  /// Parses this package's a string representation of a stack trace.
+  /// Parses this package's string representation of a stack trace.
+  ///
+  /// This also parses string representations of [Chain]s. They parse to the
+  /// same trace that [Chain.toTrace] would return.
   Trace.parseFriendly(String trace)
       : this(trace.trim().split("\n")
+          // Filter out asynchronous gaps from [Chain]s.
+          .where((line) => !line.startsWith('====='))
           .map((line) => new Frame.parseFriendly(line)));
 
   /// Returns a new [Trace] comprised of [frames].
   Trace(Iterable<Frame> frames)
       : frames = new UnmodifiableListView<Frame>(frames.toList());
 
   /// Returns a VM-style [StackTrace] object.
   ///
   /// The return value's [toString] method will always return a string
   /// representation in the Dart VM's stack trace format, regardless of what
   /// platform is being used.
   StackTrace get vmTrace => new VMTrace(frames);
 
   /// Returns a terser version of [this].
   ///
   /// This is accomplished by folding together multiple stack frames from the
-  /// core library, as in [foldFrames]. Remaining core library frames have their
-  /// libraries, "-patch" suffixes, and line numbers removed.
+  /// core library or from this package, as in [foldFrames]. Remaining core
+  /// library frames have their libraries, "-patch" suffixes, and line numbers
+  /// removed.
   Trace get terse {
-    return new Trace(foldFrames((frame) => frame.isCore).frames.map((frame) {
+    return new Trace(foldFrames((frame) {
+      return frame.isCore || frame.package == 'stack_trace';
+    }).frames.map((frame) {
       if (!frame.isCore) return frame;
       var library = frame.library.replaceAll(_terseRegExp, '');
       return new Frame(Uri.parse(library), null, null, frame.member);
     }));
   }
 
   /// Returns a new [Trace] based on [this] where multiple stack frames matching
   /// [predicate] are folded together. This means that whenever there are
   /// multiple frames in a row that match [predicate], only the last one is
   /// kept.
@@ skipping 19 matching lines @@
     // Figure out the longest path so we know how much to pad.
     var longest = frames.map((frame) => frame.location.length)
         .fold(0, math.max);
 
     // Print out the stack trace nicely formatted.
     return frames.map((frame) {
       return '${padRight(frame.location, longest)}  ${frame.member}\n';
     }).join();
   }
 }