Make Chain.parse and Trace.parse more similar.

lib/src/chain.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 stack_trace.chain;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'frame.dart';
 import 'stack_zone_specification.dart';
 import 'trace.dart';
 import 'utils.dart';
 
 /// A function that handles errors in the zone wrapped by [Chain.capture].
 typedef void ChainHandler(error, Chain chain);
 
-/// The line used in the string representation of stack chains to represent
-/// the gap between traces.
-const _gap = '===== asynchronous gap ===========================\n';
-
 /// A chain of stack traces.
 ///
 /// A stack chain is a collection of one or more stack traces that collectively
 /// represent the path from [main] through nested function calls to a particular
 /// code location, usually where an error was thrown. Multiple stack traces are
 /// necessary when using asynchronous functions, since the program's stack is
 /// reset before each asynchronous callback is run.
 ///
 /// Stack chains can be automatically tracked using [Chain.capture]. This sets
 /// up a new [Zone] in which the current stack chain is tracked and can be
@@ skipping 79 matching lines @@
   ///
   /// If [trace] is already a [Chain], it will be returned as-is.
   factory Chain.forTrace(StackTrace trace) {
     if (trace is Chain) return trace;
     if (_currentSpec == null) return new Chain([new Trace.from(trace)]);
     return _currentSpec.chainFor(trace);
   }
 
   /// Parses a string representation of a stack chain.
   ///
-  /// Specifically, this parses the output of [Chain.toString].
+  /// If [chain] is the output of a call to [Chain.toString], it will be parsed
+  /// as a full stack chain. Otherwise, it will be parsed as in [Trace.parse]
+  /// and returned as a single-trace chain.
   factory Chain.parse(String chain) {
     if (chain.isEmpty) return new Chain([]);
+    if (!chain.contains(chainGap)) return new Chain([new Trace.parse(chain)]);
+
     return new Chain(
-        chain.split(_gap).map((trace) => new Trace.parseFriendly(trace)));
+        chain.split(chainGap).map((trace) => new Trace.parseFriendly(trace)));
   }
 
   /// Returns a new [Chain] comprised of [traces].
   Chain(Iterable<Trace> traces)
       : traces = new UnmodifiableListView<Trace>(traces.toList());
 
   /// Returns a terser version of [this].
   ///
   /// This calls [Trace.terse] on every trace in [traces], and discards any
   /// trace that contain only internal frames.
@@ skipping 47 matching lines @@
       return trace.frames.map((frame) => frame.location.length)
           .fold(0, math.max);
     }).fold(0, math.max);
 
     // Don't call out to [Trace.toString] here because that doesn't ensure that
     // padding is consistent across all traces.
     return traces.map((trace) {
       return trace.frames.map((frame) {
         return '${padRight(frame.location, longest)}  ${frame.member}\n';
       }).join();
-    }).join(_gap);
+    }).join(chainGap);
   }
 }