Add Chain.foldFrames to pkg/stack_trace.

pkg/stack_trace/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 '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);
 
 /// A chain of stack traces.
 ///
 /// A stack chain is a collection of one or more stack traces that collectively
@@ skipping 145 matching lines @@
 
     // If all the traces contain only internal processing, preserve the last
     // (top-most) one so that the chain isn't empty.
     if (nonEmptyTraces.isEmpty && terseTraces.isNotEmpty) {
       return new Chain([terseTraces.last]);
     }
 
     return new Chain(nonEmptyTraces);
   }
 
+  /// Returns a new [Chain] 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. In addition, traces that are
+  /// composed entirely of frames matching [predicate] are omitted.
+  ///
+  /// This is useful for limiting the amount of library code that appears in a
+  /// stack trace by only showing user code and code that's called by user code.
+  Chain foldFrames(bool predicate(Frame frame)) {
+    var foldedTraces = traces.map((trace) => trace.foldFrames(predicate));
+    var nonEmptyTraces = foldedTraces.where((trace) {
+      // Ignore traces that contain only internal processing.
+      return trace.frames.length > 1;

[Bob Nystrom, 2014/02/25 22:10:59]

Why isn't this .isNotEmpty?

[nweiz, 2014/02/25 22:38:08]

We want to omit chains that contain only a single frame, since that's what we
get if all the frames are folded together.

[Bob Nystrom, 2014/02/25 22:58:31]

Ah, got it. Clarify the comment then.

[nweiz, 2014/02/25 23:19:46]

Done.

+    });
+
+    // If all the traces contain only internal processing, preserve the last
+    // (top-most) one so that the chain isn't empty.
+    if (nonEmptyTraces.isEmpty && foldedTraces.isNotEmpty) {
+      return new Chain([foldedTraces.last]);
+    }
+
+    return new Chain(nonEmptyTraces);
+  }
+
   /// Converts [this] to a [Trace].
   ///
   /// The trace version of a chain is just the concatenation of all the traces
   /// in the chain.
   Trace toTrace() => new Trace(flatten(traces.map((trace) => trace.frames)));
 
   String toString() => traces.join(_GAP);
 }